用 JavaScript 彻底搞懂冒泡排序:从基础实现到两种优化

3 阅读5分钟

前言

冒泡排序(Bubble Sort)大概是每个程序员接触的第一个排序算法。它在实际工程里几乎不会被用到,但思路直观、代码简短,非常适合用来理解「比较」「交换」「时间复杂度」「稳定性」这些排序的基本概念。本文用 JavaScript 从最基础的写法讲起,一步步做优化。

一、算法思想

冒泡排序的核心只有一句话:重复地比较相邻的两个元素,如果顺序不对就交换它们。

每一轮遍历结束后,当前未排序部分中最大的元素都会被「挤」到最右边,就像水里的气泡一个个浮上水面,这也是它名字的由来。

以 [5, 3, 8, 4, 2] 升序排序为例:

轮次过程本轮结果
第 1 轮5 和 3 交换,5 和 8 不动,8 和 4 交换,8 和 2 交换[3, 5, 4, 2, 8]
第 2 轮3 和 5 不动,5 和 4 交换,5 和 2 交换[3, 4, 2, 5, 8]
第 3 轮3 和 4 不动,4 和 2 交换[3, 2, 4, 5, 8]
第 4 轮3 和 2 交换[2, 3, 4, 5, 8]

n 个元素最多需要 n - 1 轮,每一轮都能确定一个元素的最终位置。

二、基础实现

function bubbleSort(arr) {
  const n = arr.length;
  // 外层循环:控制轮数,n 个元素最多 n - 1 轮
  for (let i = 0; i < n - 1; i++) {
    // 内层循环:相邻元素两两比较
    // 末尾的 i 个元素已经排好,不需要再比较
    for (let j = 0; j < n - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        // 解构赋值交换两个元素
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
}

console.log(bubbleSort([5, 3, 8, 4, 2])); // [2, 3, 4, 5, 8]

两个容易写错的地方:

  • 外层循环的条件是 i < n - 1,因为剩下最后一个元素时它必然已经在正确位置上。
  • 内层循环的条件是 j < n - 1 - i。- 1 是为了防止 arr[j + 1] 越界,- i 是跳过末尾已经排好的元素。

三、优化一:提前结束

如果某一轮遍历中一次交换都没有发生,说明数组已经有序,后面的轮次都是白跑。加一个标志位就可以提前退出:

function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let swapped = false;
    for (let j = 0; j < n - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        swapped = true;
      }
    }
    // 这一轮没有发生交换,数组已经有序
    if (!swapped) break;
  }
  return arr;
}

有了这个优化,对一个已经有序的数组排序只需要遍历一轮,最好情况的时间复杂度从 O(n²) 降到了 O(n)。

四、优化二:记录最后一次交换的位置

再进一步:每一轮最后一次发生交换的位置之后,所有元素都已经有序,下一轮只需要比较到这个位置即可。

function bubbleSort(arr) {
  let end = arr.length - 1; // 未排序部分的右边界
  while (end > 0) {
    let lastSwap = 0;
    for (let j = 0; j < end; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        lastSwap = j;
      }
    }
    // lastSwap 之后的元素都已有序
    // 如果本轮没有交换,lastSwap 为 0,循环直接结束
    end = lastSwap;
  }
  return arr;
}

对于「前半部分乱序、后半部分基本有序」的数据,这种写法能明显减少比较次数,同时它也自带了「提前结束」的效果。

五、支持自定义比较函数

实际使用时我们往往需要降序,或者按对象的某个字段排序。可以参考 Array.prototype.sort 的设计,传入一个比较函数,并且不修改原数组:

function bubbleSort(arr, compare = (a, b) => a - b) {
  const result = [...arr]; // 拷贝一份,不修改原数组
  let end = result.length - 1;
  while (end > 0) {
    let lastSwap = 0;
    for (let j = 0; j < end; j++) {
      if (compare(result[j], result[j + 1]) > 0) {
        [result[j], result[j + 1]] = [result[j + 1], result[j]];
        lastSwap = j;
      }
    }
    end = lastSwap;
  }
  return result;
}

// 降序
console.log(bubbleSort([5, 3, 8, 4, 2], (a, b) => b - a));
// [8, 5, 4, 3, 2]

// 按对象字段排序
const users = [
  { name: '张三', age: 28 },
  { name: '李四', age: 22 },
  { name: '王五', age: 25 },
];
console.log(bubbleSort(users, (a, b) => a.age - b.age).map((u) => u.name));
// ['李四', '王五', '张三']

六、复杂度与稳定性

指标结果说明
最好时间复杂度O(n)数组已有序,且做了提前结束优化
平均时间复杂度O(n²)
最坏时间复杂度O(n²)数组完全逆序,需要比较 n(n-1)/2 次
空间复杂度O(1)原地排序,只用到常数个临时变量
稳定性稳定相等的元素不会交换,相对顺序保持不变

关于稳定性要注意一点:判断条件必须是 arr[j] > arr[j + 1]。如果写成 >=,相等的元素也会被交换,算法就不再稳定了。

七、什么时候会用到它

说实话,生产环境里直接用 Array.prototype.sort 就好,V8 内部使用的是 TimSort,时间复杂度 O(n log n),并且是稳定的。

冒泡排序的价值主要在于:

  • 学习:理解排序算法的入门例子,面试中也时常被要求手写。
  • 数据量极小或基本有序:这种情况下它的实际表现并不差,而且实现简单、不占额外空间。

总结

  • 冒泡排序通过不断比较并交换相邻元素,每一轮把未排序部分的最大值移到末尾。
  • 两个常见优化:没有发生交换就提前结束;记录最后一次交换的位置来缩小下一轮的比较范围。
  • 时间复杂度 O(n²),空间复杂度 O(1),是稳定的排序算法。

如果这篇文章对你有帮助,欢迎点赞收藏,有问题也可以在评论区交流。