排序算法是计算机科学中的基本算法，它们将一个无序的数组或列表按特定顺序进行排列（如升序或降序）。常见的排序算法可以根据其时间复杂度、空间复杂度和适用场景分类。以下是几种常见的排序算法：
1. 冒泡排序（Bubble Sort）
冒泡排序是一种简单的比较排序算法。它通过不断比较相邻元素，并根据需要交换它们，逐渐将最大（或最小）的元素"冒泡"到数组的一端。
- 时间复杂度：O(n²)
- 空间复杂度：O(1)
- 稳定性：稳定
- 适用场景：适合小规模数据集，但效率较低，不适合大数据集。
算法步骤：
- 从数组的开头开始，依次比较相邻的元素，如果顺序错误则交换它们。
- 每一轮会把当前未排序部分中最大的元素放在最后的位置。
- 重复该过程，直到没有元素需要交换。
function bubbleSort(arr) {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
arr\[j\], arr\[j + 1\]\] = \[arr\[j + 1\], arr\[j\]\]; } } } return arr; } *** ** * ** *** #### 2. **选择排序（Selection Sort）** 选择排序通过在未排序的部分中找到最小（或最大）的元素，并将其与未排序部分的第一个元素交换，逐步构建有序序列。 * **时间复杂度**：O(n²) * **空间复杂度**：O(1) * **稳定性**：不稳定 * **适用场景**：适合数据规模较小，简单实现，但效率较低。 **算法步骤**： * 遍历数组，找到未排序部分的最小元素，将其与当前未排序部分的第一个元素交换。 * 重复此过程，直到整个数组排序完毕。 ``` ``` function selectionSort(arr) { for (let i = 0; i \< arr.length; i++) { let minIndex = i; for (let j = i + 1; j \< arr.length; j++) { if (arr\[j\] \< arr\[minIndex\]) { minIndex = j; } } \[arr\[i\], arr\[minIndex\]\] = \[arr\[minIndex\], arr\[i\]\]; } return arr; } *** ** * ** *** #### 3. **插入排序（Insertion Sort）** 插入排序通过从头开始逐一将元素插入到已排序部分的正确位置，从而逐步形成一个有序序列。 * **时间复杂度**：O(n²) * **空间复杂度**：O(1) * **稳定性**：稳定 * **适用场景**：适合数据量较小或部分有序的数据集。 **算法步骤**： * 从数组的第二个元素开始，将其与已排序部分的元素进行比较，并插入到正确的位置。 * 对每个元素重复此操作，直到整个数组排序完毕。 ``` ``` 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; } *** ** * ** *** #### 4. **归并排序（Merge Sort）** 归并排序是基于分治思想的排序算法，将数组不断拆分成子数组，分别对其排序后再合并。 * **时间复杂度**：O(n log n) * **空间复杂度**：O(n) * **稳定性**：稳定 * **适用场景**：适合大规模数据集，具有较高效率。 **算法步骤**： * 递归地将数组分成两个子数组。 * 对每个子数组分别进行排序。 * 合并两个有序子数组为一个完整的有序数组。 ``` ``` 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) { 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); } *** ** * ** *** #### 5. **快速排序（Quick Sort）** 快速排序也是基于分治思想。它通过选择一个"基准"元素，将数组分为两部分，一部分比基准元素小，另一部分比基准元素大，然后递归地对两部分进行排序。 * **时间复杂度**：O(n log n)（最坏情况 O(n²)） * **空间复杂度**：O(log n)（递归栈空间） * **稳定性**：不稳定 * **适用场景**：在平均情况下非常高效，适合大多数数据集。 **算法步骤**： * 选择一个基准元素（通常为第一个或最后一个）。 * 将数组分为两部分，一部分比基准小，另一部分比基准大。 * 对两部分递归进行快速排序。 * 合并两部分。 ``` ``` function quickSort(arr) { if (arr.length \<= 1) return arr; const pivot = arr\[arr.length - 1\]; let left = \[\]; let right = \[\]; for (let i = 0; i \< arr.length - 1; i++) { if (arr\[i\] \< pivot) left.push(arr\[i\]); else right.push(arr\[i\]); } return \[...quickSort(left), pivot, ...quickSort(right)\]; } *** ** * ** *** #### 6. **堆排序（Heap Sort）** 堆排序是一种基于二叉堆的数据结构的排序算法。通过构建最大堆或最小堆，每次将堆顶元素与末尾元素交换，然后继续调整堆。 * **时间复杂度**：O(n log n) * **空间复杂度**：O(1) * **稳定性**：不稳定 * **适用场景**：适合需要在原地排序的数据集。 **算法步骤**： * 构建最大堆。 * 每次将堆顶元素与数组末尾元素交换，缩小堆的范围后重新调整堆。 ``` ``` function heapify(arr, length, i) { let largest = i; let left = 2 \* i + 1; let right = 2 \* i + 2; if (left \< length \&\& arr\[left\] \> arr\[largest\]) { largest = left; } if (right \< length \&\& arr\[right\] \> arr\[largest\]) { largest = right; } if (largest !== i) { \[arr\[i\], arr\[largest\]\] = \[arr\[largest\], arr\[i\]\]; heapify(arr, length, largest); } } function heapSort(arr) { let length = arr.length; // 构建最大堆 for (let i = Math.floor(length / 2) - 1; i \>= 0; i--) { heapify(arr, length, i); } // 堆排序 for (let i = length - 1; i \> 0; i--) { \[arr\[0\], arr\[i\]\] = \[arr\[i\], arr\[0\]\]; heapify(arr, i, 0); } return arr; } *** ** * ** *** #### 总结： * **O(n²) 的算法**：冒泡排序、选择排序、插入排序------这些算法适合小规模数据集。 * **O(n log n) 的算法**：归并排序、快速排序、堆排序------适合大规模数据集，其中快速排序通常表现最好，但最坏情况为 O(n²)。