前言
冒泡排序(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),是稳定的排序算法。
如果这篇文章对你有帮助,欢迎点赞收藏,有问题也可以在评论区交流。