算法原理

1. 比较相邻的元素。如果第一个比第二个大，就交换两个元素。
2. 对每一对相邻的元素做同样的工作，从开始第一对到结尾最后一对。一次循环后，最后的元素应该会是最大的数。
3. 针对所有元素重复以上步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

外层循环控制数组的容量，内层循环一个一个比较交换排序。

时间复杂度

冒泡排序最好的时间复杂度是O(n)
最坏时间复杂度是O(n^2)
平均复杂度为O(n^2)
冒泡排序是一种稳定的排序算法。

算法实现

C语言

void bubble_sort (int a[], int n);
void bubble_sort (int a[], int n)
{ 
      int i, j, temp;
      for ( j = 0; j < n; j++) {
          for ( i = 0; i < n-1-j; i++) {
              if (a[i] > a[i + 1]) {
                    temp = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = temp;
              }
          }
      }
}

Objective-C

- (void)sort:(NSMutableArray *)array {
for (int i = 0; i < array.count; i++) {
    for (int j = 0; j < array.count-1-j; j++) {
      NSInteger left = [array[j] integerValue];
      NSInteger right = [array[j+1] integerValue];
      if (left < right) {
        [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
      }
    }
}
NSLog(@"%@",array);
}

Swift

func bubbleSort(_ array: inout [Int]) {
    let n = array.count
    for i in 0..<n {
      for j in 0..< (n-1-j) {
          if array[j] > array[j+1] {
             array.swapAt (j, j+1)
          }
      }
    }
    print(array)
}