排序第四篇 冒泡排序

在2024年2月2日， 讲解过 快速排序 ，我们已经有所了解，它和今天讲的冒泡排序 都属于 交换排序。

一 简介

交换排序的基本思想是： 两两比较待排序记录， 如果发现两个记录的次序相反时即进行交换， 直到所有记录都没有反序时为止。

本文介绍冒泡排序(Bubble Sort)
冒泡排序是一种简单的排序方法， 很多程序员对排序的接触、了解就是从冒泡排序开始的。

它的核心思想是： 通过相邻元素之间的比较和交换， 使关键字较小的元素逐渐从底部移向顶部， 就像水底下的气泡一样逐渐向上冒泡， 因此称为冒泡排序。 随着排序关键字较小的元素逐渐上移， 排序关键字较大的元素也逐渐下移， 小的上浮， 大的下沉。

---

冒泡排序过程具体描述为： 首先将 R[n] 和 R[n-1] 进行比较， 若R[n] < R[n-1], 则交换 R[n] 和R[n-1], 即 让更小的数值往上浮， 接着比较R[n-1] 和R[n-2], 同样使更小的数值上浮， 依次类推， 直到比较 R[2] 和R[1], 若反序则交换， 第一趟排序结束。
也就是说，第一趟排序， 会将整个数组中最小的数， 放在最前面(最上面)。

此时, 记录R[1] 的关键字最小， 然后再对 R[n] ~ R[2]的记录进行第二趟排序， 使次小的元素被上浮到R[2]中， 重复进行 $n-1$ 趟后， 整个冒泡排序结束。

---

以java为例， 看一个demo

public class BubbleSort {

    public static void main(String[] args) {
        Integer[] array_ = new Integer[]{30,45,10,50,30};
        System.out.println("初始顺序\n"+ Arrays.toString(array_));
        bubbleSort(Arrays.asList(array_));
        //bubbleSort_gradedown(Arrays.asList(array_));

        System.out.println("最后顺序\n"+Arrays.toString(array_));
    }

   static void bubbleSort(List<Integer> list){
        //flag 表示每一趟是否有交换， 0表示没交换；  temp表示临时变量
        int flag, temp;
        //采用自底向上扫描数组 R[1..n]做冒泡排序,  最多做 n-1趟排序
        for(int i=0; i<list.size();i++){
            flag = 0;
            //进行第i趟排序
            for(int j=list.size()-1; j>=i+1;j--) {
                //如果后面的元素 小于 前面的元素， 则交换， 也就是说小的往上浮， 显然是升序
                if (list.get(j) < list.get(j - 1)) {
                    temp = list.get(j - 1);
                    list.set(j - 1, list.get(j));
                    list.set(j, temp);
                    flag = 1;
                }
            }
            if(flag ==0) return;
        }
    }

    /**
     * 降序的写法
     */
    static void bubbleSort_gradedown(List<Integer> list){
        //flag 表示每一趟是否有交换， 0表示没交换；  temp表示临时变量
        int flag, temp;
        //采用自底向上扫描数组 R[1..n]做冒泡排序,  最多做 n-1趟排序
        for(int i=0; i<list.size();i++){
            flag = 0;
            //进行第i趟排序
            for(int j=list.size()-1; j>=i+1;j--) {
                //如果后面的元素 大于 前面的元素， 则交换， 也就是说大的往上浮， 显然是降序
                if (list.get(j) > list.get(j - 1)) {
                    temp = list.get(j - 1);
                    list.set(j - 1, list.get(j));
                    list.set(j, temp);
                    flag = 1;
                }
            }
            if(flag ==0) return;
        }
    }
}

这里用到了return, 没用break, 有什么区别？
在上述代码中 没区别, 因为 return后面没有具体代码，只剩 }
我们要清楚: return 语句会立即退出整个方法从而停止for循环，
break语句会跳出for循环，也就是结束了 for循环。

程序运行结果:

动画如下所示

冒泡排序

从 这个算法可以看出，若待排序记录为有序(最好情况)， 则一趟扫描完成， 关键字的比较次数为 $n-1$ 且没有移动， 比较的时间复杂度为 $O(n)$; 反之，若待排序记录为逆序， 则需要进行 $n-1$ 趟排序， 每趟排序需要进行 $n-i$ 次比较， 而且每次比较都必须移动记录三次才能达到交换目的。

因此，总的比较次数为: $\sum _{i=1}^{n-1}(n-i)=\frac{n(n-1)}{2}$

总的移动次数为 $\sum _{i=1}^{n-1}3(n-i)=\frac{3n(n-1)}{2}$.

在平均情况下， 比较和移动记录的总次数大约为最坏情况下的一半， 所以冒泡排序的时间复杂度为 $O(n^2)$

冒泡排序是稳定的。

二 改进的冒泡排序————— 双向冒泡排序

上述讲解的冒泡排序是从最下面往上排， 或者从最上面往下排， 只有一个方向。

双向冒泡排序 是交替改变扫描方向 ，
即一趟从下向上通过两个相邻关键字的比较， 将最小的元素换至最上面位置，
再一趟则是从第二个记录开始向下通过两个相邻记录关键字的比较，将关键字最大的记录换至最下面的位置。
依次类推， 直到全部有序为止。

以java 为例， 看一个demo

/***
 * 双向冒泡排序
 */
public class DoubleBubbleSort {

    public static void main(String[] args) {
        Integer[] array_ = new Integer[]{30,45,10,50,30};
        System.out.println("初始顺序\n"+ Arrays.toString(array_));
        doubleBubbleSort(Arrays.asList(array_));
        System.out.println("最后顺序\n"+Arrays.toString(array_));
    }

    static void doubleBubbleSort(List<Integer> list){
        int temp;
        boolean noSwap=true;
        while(noSwap){
            noSwap = false;
            //从右往左依次比较、交换
            for(int j= list.size()-1; j>=1; j--){
                if(list.get(j) < list.get(j-1)){
                     temp = list.get(j);
                     list.set(j, list.get(j-1));
                     list.set(j-1, temp);
                     noSwap = true;
                }
            }
            //从左往右依次比较、交换
            for(int i=0; i<list.size()-1; i++){
                if(list.get(i) > list.get(i+1)){
                    temp = list.get(i);
                    list.set(i, list.get(i+1));
                    list.set(i+1, temp);
                    noSwap = true;
                }
            }
        }
    }
}

程序运行结果：

动画示意如下

双向冒泡排序

请注意： 要仔细比较上述两排序， 冒泡排序用了嵌套 for循环， 双向冒泡排序外层是while循环，里层是for循环

三 时间复杂度与空间复杂度、优缺点

对于冒泡排序和双向冒泡排序，时间复杂度都为 $O(n^2)$, 空间复杂度都为 $O(1)$

冒泡排序和双向冒泡排序有什么缺点？

1. 时间复杂度高，$O(n^2)$, 意味着随着数据量的增大， 排序所需的比较和交换的次数会成平方倍增长， 对于海量数据集，此两种排序的性能较差

2. 效率较低， 从上述讲解易知， 这两种排序至少需要进行多次的比较, 虽然不一定进行交换， 在数据量大并且乱序严重时， 排序效率低。

3. 不适合海量数据集。

4. 缺乏适应性， 因为是通过相邻元素的比较和交换， 这意味着即使在部分已有序的情况下，此排序仍然会进行如此操作， 无法充分利用已排序的部分， 这一点不如 快速排序 能够跳跃式比较和交换。

冒泡排序和双向冒泡排序的优点:

稳定的， 算法简单，易实现易理解。

本文第2个动画参考了 动画算法