JavaScript排序算法详解：从基础到高级-CSDN博客

排序是编程中最基本也是最重要的操作之一。JavaScript作为一门广泛应用于Web开发的语言，提供了内置的排序方法，但了解各种排序算法的原理和实现对于开发者来说仍然至关重要。本文将深入探讨JavaScript中常见的排序算法，帮助您理解它们的原理、实现方式以及适用场景。

一、JavaScript内置排序方法

在深入探讨各种算法之前，我们先看一下JavaScript提供的原生排序方法：

const arr = [3, 1, 4, 1, 5, 9, 2, 6];
arr.sort(); // 默认按Unicode码点排序，结果为 [1, 1, 2, 3, 4, 5, 6, 9]
arr.sort((a, b) => a - b); // 数字升序排序
arr.sort((a, b) => b - a); // 数字降序排序

虽然内置的sort()方法很方便，但了解其背后的原理和各种排序算法的特性对于解决复杂问题至关重要。

二、基本排序算法

1. 冒泡排序(Bubble Sort)

原理：重复遍历要排序的列表，比较相邻元素并交换它们的位置，直到列表排序完成。

function bubbleSort(arr) {
  let len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; // ES6解构赋值交换
      }
    }
  }
  return arr;
}

时间复杂度：

最好情况：O(n)（已经排序的情况下）
平均和最坏情况：O(n²)

适用场景：小数据集或基本有序的数据

2. 选择排序(Selection Sort)

原理：每次从未排序的部分选择最小（或最大）元素放到已排序部分的末尾。

function selectionSort(arr) {
  let len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    if (minIndex !== i) {
      [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
  }
  return arr;
}

时间复杂度：始终为O(n²)

特点：交换次数少，适合交换成本高的场景

3. 插入排序(Insertion Sort)

原理：构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

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

时间复杂度：

最好情况：O(n)（已经排序的情况下）
平均和最坏情况：O(n²)

适用场景：小数据集或基本有序的数据，比冒泡和选择排序更高效

三、高效排序算法

1. 快速排序(Quick Sort)

原理：分治法策略，选择一个基准元素，将数组分为两部分，一部分小于基准，一部分大于基准，然后递归地对这两部分进行排序。

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  
  const pivot = arr[Math.floor(arr.length / 2)];
  const left = [];
  const right = [];
  const equal = [];
  
  for (let element of arr) {
    if (element < pivot) left.push(element);
    else if (element > pivot) right.push(element);
    else equal.push(element);
  }
  
  return [...quickSort(left), ...equal, ...quickSort(right)];
}

时间复杂度：

平均情况：O(n log n)
最坏情况：O(n²)（当选择的基准总是最大或最小元素时）

优化技巧：三数取中法选择基准，对小数组使用插入排序

2. 归并排序(Merge Sort)

原理：分治法策略，将数组分成两半，分别排序，然后合并两个有序数组。

function mergeSort(arr) {
  if (arr.length <= 1) return arr;
  
  const mid = Math.floor(arr.length / 2);
  const left = arr.slice(0, mid);
  const right = arr.slice(mid);
  
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;
  
  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }
  
  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

时间复杂度：始终为O(n log n)

特点：稳定排序，适合链表排序，需要额外空间

3. 堆排序(Heap Sort)

原理：利用堆这种数据结构所设计的一种排序算法，是一种选择排序。

function heapSort(arr) {
  let len = arr.length;
  
  // 构建最大堆
  for (let i = Math.floor(len / 2) - 1; i >= 0; i--) {
    heapify(arr, len, i);
  }
  
  // 一个个取出堆顶元素
  for (let i = len - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]]; // 将当前最大元素移到数组末尾
    heapify(arr, i, 0); // 重新调整堆
  }
  
  return arr;
}

function heapify(arr, len, i) {
  let largest = i;
  let left = 2 * i + 1;
  let right = 2 * i + 2;
  
  if (left < len && arr[left] > arr[largest]) {
    largest = left;
  }
  
  if (right < len && arr[right] > arr[largest]) {
    largest = right;
  }
  
  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]];
    heapify(arr, len, largest);
  }
}

时间复杂度：始终为O(n log n)

特点：原地排序，不稳定，适合大数据集

四、其他实用排序算法

1. 计数排序(Counting Sort)

原理：适用于一定范围内的整数排序，统计每个元素出现的次数，然后按顺序输出。

function countingSort(arr, maxValue) {
  const bucket = new Array(maxValue + 1).fill(0);
  let sortedIndex = 0;
  
  // 计数
  for (let i = 0; i < arr.length; i++) {
    bucket[arr[i]]++;
  }
  
  // 输出结果
  for (let j = 0; j < bucket.length; j++) {
    while (bucket[j] > 0) {
      arr[sortedIndex++] = j;
      bucket[j]--;
    }
  }
  
  return arr;
}

时间复杂度：O(n + k)，k为数据范围

适用场景：整数排序且范围不大

2. 桶排序(Bucket Sort)

原理：将数组分到有限数量的桶里，每个桶再分别排序。

function bucketSort(arr, bucketSize = 5) {
  if (arr.length === 0) return arr;
  
  // 确定最小最大值
  let minValue = arr[0];
  let maxValue = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < minValue) {
      minValue = arr[i];
    } else if (arr[i] > maxValue) {
      maxValue = arr[i];
    }
  }
  
  // 初始化桶
  const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
  const buckets = new Array(bucketCount);
  for (let i = 0; i < buckets.length; i++) {
    buckets[i] = [];
  }
  
  // 分配到桶中
  for (let i = 0; i < arr.length; i++) {
    buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
  }
  
  // 对每个桶排序并合并
  arr.length = 0;
  for (let i = 0; i < buckets.length; i++) {
    insertionSort(buckets[i]); // 使用插入排序或其他排序算法
    for (let j = 0; j < buckets[i].length; j++) {
      arr.push(buckets[i][j]);
    }
  }
  
  return arr;
}

时间复杂度：平均O(n + k)，最坏O(n²)

适用场景：数据均匀分布在一定范围内

五、算法比较与选择建议

算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性	适用场景
冒泡排序	O(n²)	O(n²)	O(1)	稳定	小数据集或教学
选择排序	O(n²)	O(n²)	O(1)	不稳定	交换成本高的场景
插入排序	O(n²)	O(n²)	O(1)	稳定	小数据集或基本有序
快速排序	O(n log n)	O(n²)	O(log n)	不稳定	通用排序，性能好
归并排序	O(n log n)	O(n log n)	O(n)	稳定	大数据集，需要稳定排序
堆排序	O(n log n)	O(n log n)	O(1)	不稳定	大数据集，原地排序
计数排序	O(n + k)	O(n + k)	O(k)	稳定	整数且范围小
桶排序	O(n + k)	O(n²)	O(n + k)	稳定	数据均匀分布

选择建议：

小数据集（n < 100）：插入排序简单高效
通用场景：快速排序通常是最佳选择
需要稳定排序：归并排序
内存有限：堆排序
已知数据范围：计数排序或桶排序

六、JavaScript引擎中的排序实现

现代JavaScript引擎（如V8）的Array.prototype.sort()实现通常采用混合排序策略：

对于小数组（长度<10），使用插入排序
对于大数组，使用快速排序或归并排序
针对特定类型数组（如整数数组）可能有优化路径

七、性能测试示例

function testSortPerformance(sortFn, arr) {
  const start = performance.now();
  sortFn([...arr]); // 使用副本避免修改原数组
  const end = performance.now();
  return end - start;
}

const largeArray = Array.from({length: 10000}, () => Math.floor(Math.random() * 10000));

console.log('冒泡排序:', testSortPerformance(bubbleSort, largeArray), 'ms');
console.log('快速排序:', testSortPerformance(quickSort, largeArray), 'ms');
console.log('原生排序:', testSortPerformance(arr => arr.sort((a, b) => a - b), largeArray), 'ms');