在 JavaScript 中，可以实现多种经典的排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序等。以下是这些排序算法的实现代码和解释：
1. 冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法，通过重复地遍历要排序的列表，比较相邻的元素并交换它们的位置来排序。
javascript
function bubbleSort(arr) {
const n = arr.length;
for (let i = 0; i < n - 1; 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]2. 选择排序（Selection Sort）
选择排序是一种简单的排序算法，通过反复地从未排序部分选择最小的元素，并将其放到已排序部分的末尾来排序。
javascript
function selectionSort(arr) {
const n = arr.length;
for (let i = 0; i < n - 1; i++) {
let minIndex = i;
for (let j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex !== i) {
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; // 交换元素
}
}
return arr;
}
// 示例
console.log(selectionSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]3. 插入排序（Insertion Sort）
插入排序是一种简单的排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
javascript
function insertionSort(arr) {
const n = arr.length;
for (let i = 1; i < n; 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;
}
// 示例
console.log(insertionSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]4. 归并排序（Merge Sort）
归并排序是一种分治算法，将数组分成两个子数组，分别排序，然后合并两个已排序的子数组。
javascript
function mergeSort(arr) {
if (arr.length <= 1) {
return arr;
}
const mid = Math.floor(arr.length / 2);
const left = mergeSort(arr.slice(0, mid));
const right = mergeSort(arr.slice(mid));
return merge(left, right);
}
function merge(left, right) {
const 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);
}
// 示例
console.log(mergeSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]5. 快速排序（Quick Sort）
快速排序是一种分治算法，通过选择一个基准元素，将数组分成两部分，一部分小于基准元素，另一部分大于基准元素，然后递归地排序两部分。
javascript
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
const pivot = arr[Math.floor(arr.length / 2)];
const left = [];
const right = [];
for (let i = 0; i < arr.length; i++) {
if (i === Math.floor(arr.length / 2)) continue;
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat(pivot, quickSort(right));
}
// 示例
console.log(quickSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]6. 堆排序（Heap Sort）
堆排序是一种基于堆数据结构的排序算法，利用堆的性质进行排序。
javascript
function heapSort(arr) {
const n = arr.length;
// 构建最大堆
for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 逐个从堆中取出元素
for (let i = n - 1; i > 0; i--) {
[arr[0], arr[i]] = [arr[i], arr[0]]; // 交换元素
heapify(arr, i, 0);
}
return arr;
}
function heapify(arr, n, i) {
let largest = i;
const left = 2 * i + 1;
const right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest !== i) {
[arr[i], arr[largest]] = [arr[largest], arr[i]]; // 交换元素
heapify(arr, n, largest);
}
}
// 示例
console.log(heapSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]总结
这些排序算法各有优缺点，适用于不同的场景：
- 冒泡排序：简单但效率低，适用于小规模数据。
- 选择排序：简单但效率低，适用于小规模数据。
- 插入排序：简单且在部分有序数据中表现较好。
- 归并排序：稳定且效率高，适用于大规模数据。
- 快速排序：效率高但不稳定，适用于大规模数据。
- 堆排序：效率高且不稳定，适用于大规模数据。