用JavaScript实现排序算法
冒泡排序，插入排序，快速排序，归并排序，桶排序，选择排序
1. 冒泡排序
1.1实现思路
每次比较相邻两个元素，如果前面的比后面大，就交换。
每一轮都会把最大的元素 "冒泡"到最后。
第一轮结束，后面的依次类推
1.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好(O) | O(n)（加优化） |
| 平均 | O(n²) |
| 最坏 | O(n²) |
1.3 是否稳定
稳定排序
1.4 JS代码
javascript
function bubbleSort(arr) {
let 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;
}
let arr = [5,2,9,1,3,6];
console.log(bubbleSort(arr));2. 插入排序
2.1 实现思路
左边已经排好序。
拿右边一个元素，插入到左边合适位置。
例如：
5 | 2 9 1 3
把2插进去
2 5 | 9 1 3
再拿9
2 5 9 | 1 3
拿1
1 2 5 9 | 3
直到结束。
2.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好 | O(n) |
| 平均 | O(n²) |
| 最坏 | O(n²) |
2.3 是否稳定
稳定排序
2.4 JS代码
javascript
function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
let key = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
return arr;
}
let arr = [5,2,9,1,3,6];
console.log(insertionSort(arr));3. 选择排序
3.1 实现思路
每一轮：找最小值，放到当前位置。
例如
5 2 9 1 3
第一轮：找到最小值：1
和第一个元素交换
1 2 9 5 3
第二轮：剩余里面找最小2
不用交换
依次类推
3.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好 | O(n²) |
| 平均 | O(n²) |
| 最坏 | O(n²) |
3.3 是否稳定
不稳定
交换最小元素时可能改变相同元素的相对位置。
3.4 JS代码
javascript
function selectionSort(arr) {
let n = arr.length;
for (let i = 0; i < n - 1; i++) {
let min = i;
for (let j = i + 1; j < n; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
[arr[i], arr[min]] = [arr[min], arr[i]];
}
return arr;
}
let arr = [5,2,9,1,3,6];
console.log(selectionSort(arr));4. 快速排序
4.1 实现思路
快速排序采用分治思想
例一：
找一个基准值
例如：5 2 9 1 3 6
选：5
然后分成：
比5小：2 1 3
比5大：9 6
变成
2 1 3
5
9 6
左右继续递归。
最终
1 2 3 5 6 9
例二：
4.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好 | O(n log n) |
| 平均 | O(n log n) |
| 最坏 | O(n²) |
4.3 是否稳定
不稳定
4.4 JS代码（递归）
javascript
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
let pivot = arr[0];
let left = [];
let right = [];
for (let i = 1; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return [...quickSort(left), pivot, ...quickSort(right)];
}
let arr = [5,2,9,1,3,6];
console.log(quickSort(arr));5. 归并排序
5.1 实现思路
也是分治 一直拆
例如
5 2 9 1 3 6
拆成
5 2 9
1 3 6
继续拆
5
2
9
1
3
6
最后开始合并。
5 2
↓
2 5
2 59
↓
2 5 9
最终
1 2 3 5 6 9
5.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好 | O(n log n) |
| 平均 | O(n log n) |
| 最坏 | O(n log n) |
5.3 是否稳定
稳定排序
5.4 JS代码
javascript
function merge(left, right) {
let result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
return result.concat(left, right);
}
function mergeSort(arr) {
if (arr.length <= 1) {
return arr;
}
let mid = Math.floor(arr.length / 2);
let left = mergeSort(arr.slice(0, mid));
let right = mergeSort(arr.slice(mid));
return merge(left, right);
}
let arr = [5,2,9,1,3,6];
console.log(mergeSort(arr));6. 桶排序
6.1 实现思路
桶排序适用于数据分布较均匀的情况。
步骤：
- 建多个桶
0~9
10~19
20~29
...
例如
29 25 11 35 18
放桶
桶1：11 18
桶2：25 29
桶3：35
每个桶内部排序
最后依次输出
桶内排序算法的选择
6.2 时间复杂度
| 情况 | 复杂度 |
|---|---|
| 最好 | O(n + k) |
| 平均 | O(n + k) |
| 最坏 | O(n²) |
n：元素个数
k：桶的数量
6.3 是否稳定
若桶内使用稳定排序（如插入排序），则整体可以稳定。
6.4 JS代码
javascript
function bucketSort(arr, bucketSize = 5) {
if (arr.length === 0) return arr;
let min = Math.min(...arr);
let max = Math.max(...arr);
let bucketCount = Math.floor((max - min) / bucketSize) + 1;
let buckets = Array.from({ length: bucketCount }, () => []);
// 放入桶中
for (let num of arr) {
let index = Math.floor((num - min) / bucketSize);
buckets[index].push(num);
}
// 每个桶内使用插入排序
function insertionSort(bucket) {
for (let i = 1; i < bucket.length; i++) {
let key = bucket[i];
let j = i - 1;
while (j >= 0 && bucket[j] > key) {
bucket[j + 1] = bucket[j];
j--;
}
bucket[j + 1] = key;
}
return bucket;
}
let result = [];
for (let bucket of buckets) {
insertionSort(bucket);
result.push(...bucket);
}
return result;
}
let arr = [29,25,3,49,9,37,21,43];
console.log(bucketSort(arr));