排序算法（一） 冒泡排序

这是数学

本文:https://www.jianshu.com/p/ed961771af24

冒泡排序 （Bubble Sort）

这个算法的名字由来是因为越小的元素会经由交换慢慢 “浮” 到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

基本思想

两个数比较大小，较大的数下沉，较小的数冒起来。

算法原理

冒泡排序算法的原理如下：

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

实现方式

    /**
     * Java
     * 冒泡排序
     *
     * @param arr data source
     */
    public static void bubbleSort(int arr[]) {
        if (arr == null) {
            return;
        }
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

时间复杂度 O(n^2)

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：
C min = n - 1
M min = 0;
所以，冒泡排序最好的时间复杂度为O(n)。

若初始文件是反序的，需要进行 n - 1 趟排序。每趟排序要进行 n - i 次关键字的比较(1 ≤ i ≤ n-1)，且每次比较都必须移动记录三次来达到交换记录位置。
在这种情况下，比较和移动次数均达到最大值：
C max = n (n - 1) / 2 = O(n^2)
M max = 3n(n - 1) / 2 = O(n^2);
冒泡排序的最坏时间复杂度为O(n^2)。

综上，因此冒泡排序总的平均时间复杂度为O(n^2)。

空间复杂度 O(1)

冒泡排序排序过程中需要一个临时变量进行两两交换，所需要的额外空间为1，因此空间复杂度为O(1)。

算法稳定性 – 稳定

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

优化

针对问题：
数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，直到arr.length-1次，后面的比较没有意义的。

方案：
设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false。
这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去。

    /**
     * Java
     * 冒泡排序
     *
     * @param arr data source
     */
    public static void bubbleSort(int arr[]) {
        if (arr == null) {
            return;
        }
        int temp;//临时变量
        boolean flag;//是否交换的标志
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            // 每次遍历标志位都要先置为false，才能判断后面的元素是否发生了交换
            flag = false;
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;    // 只要有发生了交换，flag就置为true
                }
            }
            // 判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接break
            if (!flag) break;
        }
    }

参考

百度百科 - 冒泡排序 (https://baike.baidu.com/item/冒泡排序)

值得收藏的十大经典排序算法 (https://www.toutiao.com/a6593273307280179715)