JavaScript 实现常见排序算法

JavaScript 实现常见排序算法

下面是几种经典排序算法的 JavaScript 实现，包括时间复杂度分析和代码示例。

1. 冒泡排序 (Bubble Sort)

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定

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([64, 34, 25, 12, 22, 11, 90]));

2. 选择排序 (Selection Sort)

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：不稳定

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([64, 25, 12, 22, 11]));

3. 插入排序 (Insertion Sort)

时间复杂度：O(n²) (最坏/平均)，O(n) (最好)
空间复杂度：O(1)
稳定性：稳定

function insertionSort(arr) {
  const n = arr.length;
  for (let i = 1; i < n; i++) {
    const 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([12, 11, 13, 5, 6]));

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 = [];
  let i = 0, 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.concat(left.slice(i)).concat(right.slice(j));
}

// 使用示例
console.log(mergeSort([38, 27, 43, 3, 9, 82, 10]));

5. 快速排序 (Quick Sort)

时间复杂度：O(n log n) (平均)，O(n²) (最坏)
空间复杂度：O(log n)
稳定性：不稳定

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left < right) {
    const pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  const pivot = arr[right];
  let i = left;
  
  for (let j = left; j < right; j++) {
    if (arr[j] < pivot) {
      [arr[i], arr[j]] = [arr[j], arr[i]];
      i++;
    }
  }
  
  [arr[i], arr[right]] = [arr[right], arr[i]];
  return i;
}

// 使用示例
console.log(quickSort([10, 80, 30, 90, 40, 50, 70]));

6. 堆排序 (Heap Sort)

时间复杂度：O(n log n)
空间复杂度：O(1)
稳定性：不稳定

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([12, 11, 13, 5, 6, 7]));

7. 计数排序 (Counting Sort)

时间复杂度：O(n + k)
空间复杂度：O(n + k)
稳定性：稳定
适用场景：整数排序，范围不大时效率高

function countingSort(arr) {
  const max = Math.max(...arr);
  const min = Math.min(...arr);
  const range = max - min + 1;
  const count = new Array(range).fill(0);
  const output = new Array(arr.length);
  
  // 统计每个元素出现的次数
  for (let num of arr) {
    count[num - min]++;
  }
  
  // 计算累计次数
  for (let i = 1; i < count.length; i++) {
    count[i] += count[i - 1];
  }
  
  // 反向填充输出数组
  for (let i = arr.length - 1; i >= 0; i--) {
    output[count[arr[i] - min] - 1] = arr[i];
    count[arr[i] - min]--;
  }
  
  return output;
}

// 使用示例
console.log(countingSort([4, 2, 2, 8, 3, 3, 1]));

这些排序算法各有优缺点，适用于不同的场景。简单排序（冒泡、选择、插入）适合小规模数据，而快速排序、归并排序和堆排序适合大规模数据排序。计数排序则适用于整数且范围不大的特殊情况。