【前端也要学算法系列】经典排序算法JS实现 —— 冒泡排序

一以贯之的努力，不得懈怠的人生。——长洱《天才基本法》

冒泡排序（Bubble Sort）

它会遍历 数据总个数减一 次需要排序的数列，

每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置（也可能反之，根据需求）。

这样，一次遍历之后，最大的元素就在数列的末尾！

采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。

重复此操作，直到整个数列都有序为止！

时间复杂度

什么时候最快？

当输入的数据已经是正序时（都已经是正序了，我还要你冒泡排序有何用啊）。

最好情况：O(N)

什么时候最慢？

当输入的数据是反序时（写一个 for 循环反序输出数据不就行了，干嘛要用你冒泡排序呢，我是闲的吗）。

最坏情况：O(N^2)

空间复杂度

空间复杂度：O(1)

平均时间复杂度计算

比较次数是

(n-1) + (n-2) + (n-3) +.....+ 1 = n(n-1)/2

JS代码实现

function bubbleSort(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                let temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

带上冒泡刷LeetCode

题目

非递减顺序，即非严格递减，可能存在相邻元素相等的情况。

使用冒泡（简单易手写）解题

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
var merge = function(nums1, m, nums2, n) {

    //合并数组
    for(let i = 0; i < n; i++){
        nums1[m+i] = nums2[i]
    }
    //外层循环，控制趟数，每一次找到一个最大值
    for (let i = 0; i < nums1.length - 1; i++) {
        // 内层循环,控制比较的次数，并且判断两个数的大小
        for (let j = 0; j < nums1.length - 1 - i; j++) {
            //如果前面的数大，放到后面(当然是从小到大的冒泡排序)
            if (nums1[j] > nums1[j + 1]) {
                let temp = nums1[j];
                nums1[j] = nums1[j + 1];
                nums1[j + 1] = temp;
            }
        }
 
    }
};

顺利通过。

我是capybara，你的编程学习伙伴，欢迎留言讨论和点赞支持。