冒泡排序

冒泡排序是个著名的简单排序算法。而其基本只在介绍排序算法时才会被用到(呵呵呵)。

复杂度：O(n^2)

算法

1.从数组起始，对比每对相邻的元素，如果逆序，交换它们；

2.如果上步骤由交换，重复步骤1.

可以把数字想象成泡泡，每轮交换大的泡泡都向上浮动。到没有泡泡移动，排序结束。下面看个例子：

对数组{5, 1, 12, -5, 16}进行冒泡排序。

复杂度分析

平均和最坏复杂度都是O(n^2)。并且，在最坏情况下进行O(n^2)次交换。冒泡排序是适应性算法，即对排好序的数组，复杂度为O(n)。

乌龟和兔子

冒泡排序的一个很大问题是：它的运行时间依赖于数组的初始排序。大的数(兔子)上升得很快，而小的数(乌龟)下降的很慢。这个问题在鸡尾酒排序(Cocktail sort)中得到解决。

乌龟实例

数组{2, 3, 4, 5, 1}基本排序好了，需要O(n^2)的迭代步骤数，其中{1}就是乌龟元素。

兔子例子

属猪{6, 1, 2, 3, 4, 5}基本已排序，需要O(n)的迭代步骤数。元素{6}为兔子。这个例子充分展示了冒泡排序的适应性。

实例

Java实现

public void bubbleSort(int[] arr) {
      boolean swapped = true;
      int j = 0;
      int tmp;
      while (swapped) {
            swapped = false;
            j++;
            for (int i = 0; i < arr.length - j; i++) {                                       
                  if (arr[i] > arr[i + 1]) {                          
                        tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;
                        swapped = true;
                  }
            }                
      }
}

C++实现

void bubbleSort(int arr[], int n) {
      bool swapped = true;
      int j = 0;
      int tmp;
      while (swapped) {
            swapped = false;
            j++;
            for (int i = 0; i < n - j; i++) {
                  if (arr[i] > arr[i + 1]) {
                        tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;
                        swapped = true;
                  }
            }
      }
}