经典排序算法大比拼：从简单到精湛，全都要！

前端

2023-09-14 12:07:00

排序算法，大有乾坤

排序，就是将一组数据按照一定的规则重新排列，使其具有某种特定顺序。在计算机科学中，排序算法是一类用于对数据进行排序的算法，它是编程的基本功之一。

排序算法有很多种，每种算法都有其独特的特点和适用场景。有些算法简单易懂，但效率较低；有些算法复杂度较高，但效率很高。那么，我们该如何选择适合自己的排序算法呢？

算法性能大比拼

为了帮助你更好地理解和选择排序算法，我们用JavaScript实现了几种常用的排序算法，并对它们的性能进行了比较。以下是各算法的平均时间复杂度：

选择排序：O(n^2)
插入排序：O(n^2)
归并排序：O(n log n)
快速排序：O(n log n)
堆排序：O(n log n)

算法实现，一探究竟

下面，我们来看看每种算法的JavaScript实现。

选择排序

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

插入排序

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

归并排序

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) {
  const result = [];
  while (left.length && right.length) {
    if (left[0] < right[0]) {
      result.push(left.shift());
    } else {
      result.push(right.shift());
    }
  }
  return [...result, ...left, ...right];
}

快速排序

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const pivot = arr[0];
  const left = [];
  const right = [];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
}

堆排序

function heapSort(arr) {
  const heap = buildHeap(arr);
  const sorted = [];
  while (heap.length) {
    sorted.push(heap.pop());
    heapify(heap, 0);
  }
  return sorted;
}

function buildHeap(arr) {
  for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
    heapify(arr, i);
  }
  return arr;
}

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