【一起学习排序算法】2 冒泡排序-CSDN博客

冒泡排序 Bubble sort

本系列的文章列表和相关说明，请查看【一起学习排序算法】0 序言
也可以直接到github上查看完整的文章和源码！

原理

先看看Wikipedia的定义：

Bubble sort is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.

所以冒泡排序就是，每次比较相邻的两个元素，如果顺序不对，则交换元素。每一次迭代，最大的元素会排到列表的一侧。然后重复这个步骤，直到不需要交换元素，该数组即有序了。

图示

可以通过动画演示理解, 以下网上找的两个动画。如果你想操作不同的参数来演示，可以上这个网站visualgo.net动手试试。

代码实现

关于代码，README中代码只有实现算法的函数，具体运行的代码，请查看该目录下的文件。

初始冒泡

代码如下, 看bubble_sort_1.js。

const bubbleSort = (array) => {
    // 不修改原数组
    const originValues = array.slice(); 

    // 迭代次数 数组长度-1
    for (let i = 0; i < originValues.length - 1; i++) {
        // 两两比较，该迭代的最大数，移动到右侧相应位置
        for (let j = 0; j < originValues.length - 1 - i; j++) {
            // 如果前一个数，大于后一个数，交换
            if (originValues[j] > originValues[j + 1]) {
                const tmp = originValues[j];
                originValues[j] = originValues[j + 1];
                originValues[j + 1] = tmp;
            }
        }
    }

    return originValues;
};
复制代码

代码其实已经很明显了。最外层循环控制迭代次数，内层循环两两比较，把较大的数往右移动。不过有几点要提一下：

最外层循环为 (length-1)
这个看很多实现都是外层循环length次，其实最后一次多余了，因为只要前 n-1 都排序之后，第一个数肯定是最小的数了。
内层循环可以忽略已经排好序的元素
每过n轮，则最右侧的n个元素肯定有序了。交换排序的时候，可以忽略这些元素。所以内层循环的终止游标是length-1-i。

复杂度分析：
很明显，不管数组正序还是逆序，复杂度都是O(n²),所以最优复杂度和最坏复杂度都是O(n²)。可资料上都是说，冒泡排序的最优复杂度是O(n)啊，那上面这种实现，肯定可以优化。
仔细复盘上面的流程发现: 如果数组正序，比较一轮数组之后，后面还会傻傻地重复进行比较。而这其实是没有必要的。只要在某一轮比较中，没有发生元素互换，就可以确认数组已经有序了。

改进的冒泡

代码如下, 看bubble_sort_2.js。

const bubbleSort = (array) => {
    // 不修改原数组
    const originValues = array.slice(); 

    let swapped = true;
    do {
        // 标记该次迭代是否交换顺序，如果没有，代表列表已经有序
        swapped = false;
        for (let i = 0; i < originValues.length - 1; i++) {
            // 如果前一元素大于后一元素，交换顺序
            if (originValues[i] > originValues[i + 1]) {
                const tmp = originValues[i];
                originValues[i] = originValues[i + 1];
                originValues[i + 1] = tmp;
                // 如果有交换，标记继续下一轮
                swapped = true;
            }
        }
    } while (swapped);

    return originValues;
};
复制代码

复杂度分析：
经过上面的改造：当数组正序时，也就是最优复杂度达到了O(n)；当数组逆序时，为最坏复杂度，为O(n²)。
咋一看，貌似是最终解了。但复盘之后，发现每轮已经排序的元素，还会重复去比较。所以还可以小优化一下。

冒泡再修改

代码如下, 看bubble_sort_3.js。

const bubbleSort = (array) => {
    // 不修改原数组
    const originValues = array.slice(); 

    let swapped = true;
    let hasOrderedCnt = 0; // 已排序个数
    do {
        // 标记该次迭代是否交换顺序，如果没有，代表列表已经有序
        swapped = false;
        for (let i = 0; i < originValues.length - 1 - hasOrderedCnt; i++) {
            // 如果前一元素大于后一元素，交换顺序
            if (originValues[i] > originValues[i + 1]) {
                const tmp = originValues[i];
                originValues[i] = originValues[i + 1];
                originValues[i + 1] = tmp;
                swapped = true;
            }
        }
        // 每一轮之后，都有一个元素排好顺序
        hasOrderedCnt++;
    } while (swapped);

    return originValues;
};
复制代码