常用排序之冒泡排序

冒泡排序

• 双层循环控制
  外层循环控制次数：N-1次
  内层循环控制比较范围：第一次 j+1要取到N-1，即j+1 < N；最后一次j+1取到1，即j+1 < 2

for (int i = 0; i < N-1; i++) { // need N-1 times (if there is only one, no need to sort)
    for (int j = 0; j + 1 < N - i; j++) { //  j + 1 < N - i, i [0, N-1)

• 及时退出
  如果该次没有交换任何元素

• 复杂度分析

  1. 若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 和记录移动次数 M 均达到最小值：n-1，0 。所以，冒泡排序最好时间复杂度为O(n)。
  2. 若初始文件是反序的，需要进行 n-1 趟排序。每趟排序要进行 n-i 次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来交换记录位置。在这种情况下，比较和移动次数均达到最大值：n(n-1)/2，3n(n-1)/2。所以，冒泡排序的最坏时间复杂度为O(n^2)。
  3. 综上，冒泡排序总的平均时间复杂度为O(n^2)

• 适用性
  适合原本比较有序的情况

• 算法稳定性
  

  • 稳定
    

  冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

---

示例

double price [] = new double[N];    
double perPrice [] = new double[N];  
double temp = 0;

// 降序
for (int i = N-1; i > 0; i--) { // N-1 ... 1 
    for (int j = 0; j < i; j++) { 
        if(perPrice[j] < perPrice[j+1]){  // 小的往后移

            temp = perPrice[j];
            perPrice[j] = perPrice[j+1];
            perPrice[j+1] = temp;

            temp = count[j];
            count[j] = count[j+1];
            count[j+1] = temp;
        }
    }
}

// 升序
for (int i = 1; i < N; i++) { // 1...N-1
    for (int j = 0; j < N-i; j++) {
        if(perPrice[j] > perPrice[j+1]){  // 大的往后移

            temp = perPrice[j];
            perPrice[j] = perPrice[j+1];
            perPrice[j+1] = temp;

            temp = count[j];
            count[j] = count[j+1];
            count[j+1] = temp;
        }
    }
}

及时退出

void bubbleSort(T a[], int size){
    boolean flag;
    T tmp;

    for(int i = 1; i < size; ++i){
        flag = false;

        for(int j = 0; j < size - i; ++j){
            if(a[j] > a[j+1]){
                tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;

                flag = true;
            }
        }

        if(!flag){
            break;
        }
    }
}