JavaScript 中的六种排序算法：全面指南

排序算法在 JavaScript 中的实现与分析

排序算法在计算机科学中至关重要，用于将数据元素按照特定顺序排列。它们广泛应用于各种场景，从管理数据集合到优化搜索和信息检索。

JavaScript 作为一门强大的编程语言，提供了多种排序算法的实现，每个算法都有其独特的优势和劣势。本文将深入探讨六种流行的 JavaScript 排序算法，包括 Bubble Sort、Insertion Sort、Selection Sort、Merge Sort、Quick Sort 和 Heap Sort。

1. Bubble Sort

Bubble Sort 是一种简单的排序算法，通过不断比较相邻元素并交换位置，将较大元素逐步移动到数组末尾。它的时间复杂度为 O(n^2)，对于大型数组来说效率较低。

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. Insertion Sort

Insertion Sort 是一种通过逐个插入未排序元素到已排序部分来工作的算法。它的平均时间复杂度为 O(n^2)，但对于部分有序的数组来说效率较高。

function insertionSort(arr) {
  for (let i = 1; i < arr.length; i++) {
    let current = arr[i];
    let j = i - 1;
    while (j >= 0 && current < arr[j]) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = current;
  }
  return arr;
}

3. Selection Sort

Selection Sort 每次从未排序部分中找到最小（或最大）元素，并将其交换到合适的位置。它的时间复杂度也为 O(n^2)，但它在小数组上比 Bubble Sort 快。

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;
}

4. Merge Sort

Merge Sort 是一种分治排序算法，通过递归地将数组分成较小的部分，然后将排序后的部分合并在一起。它的时间复杂度始终为 O(n log 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) {
  const result = [];
  let i = 0;
  let j = 0;
  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      result.push(left[i++]);
    } else {
      result.push(right[j++]);
    }
  }
  return [...result, ...left.slice(i), ...right.slice(j)];
}

5. Quick Sort

Quick Sort 是一种快速高效的分治排序算法。它选择一个枢轴元素，将数组划分为两个部分，然后递归地对这两个部分进行排序。Quick Sort 的平均时间复杂度为 O(n log n)，但最坏情况下为 O(n^2)。

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 (arr[i] < pivot) {
      left.push(arr[i]);
    } else if (arr[i] > pivot) {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
}

6. Heap Sort

Heap Sort 是一种基于二叉堆数据结构的排序算法。它将数组构建为一个堆，然后从堆中提取元素，形成排序后的数组。Heap Sort 的平均和最坏时间复杂度均为 O(n log n)。

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) {
  const 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);
  }
}

总结

选择最合适的排序算法取决于具体的数据集和应用程序需求。对于小型数组或部分有序的数组，Insertion Sort 或 Selection Sort 可能更有效。对于大型数组或要求时间复杂度一致的应用程序，Merge Sort 或 Quick Sort 是理想的选择。对于内存受限的环境，Heap Sort 可能是更好的选择。

总之，JavaScript 提供了多种高效的排序算法，通过仔细选择和实施，您可以显著提高应用程序的性能和效率。