JavaScript中十大经典的排序算法介绍与比较

排序算法是计算机科学中的基本算法之一。它将一组元素按照某种顺序排列，以便于后续处理。排序算法有很多种，每种算法都有自己的特点和适用场景。

十大JavaScript排序算法:

1. 冒泡排序（Bubble Sort）

冒泡排序是一种最简单的排序算法。它的基本思想是：每次从数组的开头开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，就交换它们的顺序。这样，最大的元素就会逐渐“浮”到数组的末尾。

function bubbleSort(array) {
  for (let i = 0; i < array.length; i++) {
    for (let j = 0; j < array.length - i - 1; j++) {
      if (array[j] > array[j + 1]) {
        const temp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = temp;
      }
    }
  }

  return array;
}

2. 选择排序（Selection Sort）

选择排序是一种简单而有效的排序算法。它的基本思想是：每次从数组中找到最小的元素，然后将其与数组的第一个元素交换。这样，最小的元素就会被放到数组的开头。

function selectionSort(array) {
  for (let i = 0; i < array.length; i++) {
    let minIndex = i;
    for (let j = i + 1; j < array.length; j++) {
      if (array[j] < array[minIndex]) {
        minIndex = j;
      }
    }

    const temp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = temp;
  }

  return array;
}

3. 插入排序（Insertion Sort）

插入排序是一种简单的排序算法，经常用于对小规模数组进行排序。它的基本思想是：将一个元素插入到已经排好序的数组中，使得数组仍然保持有序。

function insertionSort(array) {
  for (let i = 1; i < array.length; i++) {
    let currentElement = array[i];
    let j = i - 1;

    while (j >= 0 && array[j] > currentElement) {
      array[j + 1] = array[j];
      j--;
    }

    array[j + 1] = currentElement;
  }

  return array;
}

4. 希尔排序（Shell Sort）

希尔排序是一种改进的插入排序算法。它的基本思想是：将数组分成若干个子数组，然后对每个子数组进行插入排序。这样，可以提高排序的效率。

function shellSort(array) {
  let gap = Math.floor(array.length / 2);

  while (gap > 0) {
    for (let i = gap; i < array.length; i++) {
      let currentElement = array[i];
      let j = i - gap;

      while (j >= 0 && array[j] > currentElement) {
        array[j + gap] = array[j];
        j -= gap;
      }

      array[j + gap] = currentElement;
    }

    gap = Math.floor(gap / 2);
  }

  return array;
}

5. 归并排序（Merge Sort）

归并排序是一种分治排序算法。它的基本思想是：将数组分成若干个子数组，然后对每个子数组进行排序，最后将排好序的子数组合并起来。

function mergeSort(array) {
  if (array.length <= 1) {
    return array;
  }

  const middleIndex = Math.floor(array.length / 2);
  const leftArray = mergeSort(array.slice(0, middleIndex));
  const rightArray = mergeSort(array.slice(middleIndex));

  return merge(leftArray, rightArray);
}

function merge(leftArray, rightArray) {
  const mergedArray = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < leftArray.length && rightIndex < rightArray.length) {
    if (leftArray[leftIndex] < rightArray[rightIndex]) {
      mergedArray.push(leftArray[leftIndex]);
      leftIndex++;
    } else {
      mergedArray.push(rightArray[rightIndex]);
      rightIndex++;
    }
  }

  while (leftIndex < leftArray.length) {
    mergedArray.push(leftArray[leftIndex]);
    leftIndex++;
  }

  while (rightIndex < rightArray.length) {
    mergedArray.push(rightArray[rightIndex]);
    rightIndex++;
  }

  return mergedArray;
}

6. 快速排序（Quick Sort）

快速排序是一种分治排序算法。它的基本思想是：选择一个基准元素，然后将数组分成两部分，一部分包含小于基准元素的元素，另一部分包含大于基准元素的元素。然后，对每个部分递归地应用快速排序。

function quickSort(array) {
  if (array.length <= 1) {
    return array;
  }

  const pivot = array[array.length - 1];
  const leftArray = [];
  const rightArray = [];

  for (let i = 0; i < array.length - 1; i++) {
    if (array[i] < pivot) {
      leftArray.push(array[i]);
    } else {
      rightArray.push(array[i]);
    }
  }

  return [...quickSort(leftArray), pivot, ...quickSort(rightArray)];
}

7. 堆排序（Heap Sort）

堆排序是一种选择排序算法。它的基本思想是：将数组构建成一个二叉堆，然后不断从堆中删除最小的元素，直到堆为空。

function heapSort(array) {
  buildMaxHeap(array);

  for (let i = array.length - 1; i > 0; i--) {
    const temp = array[0];
    array[0] = array[i];
    array[i] = temp;

    heapify(array, 0, i);
  }

  return array;
}

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

function heapify(array, index, heapSize) {
  const leftIndex = 2 * index + 1;
  const rightIndex = 2 * index + 2;
  let largestIndex = index;

  if (leftIndex < heapSize && array[leftIndex] > array[largestIndex]) {
    largestIndex = leftIndex;
  }

  if (rightIndex < heapSize && array[rightIndex] > array[largestIndex]) {
    largestIndex = rightIndex;
  }

  if (largestIndex !== index) {
    const temp = array[index];
    array[index] = array[largestIndex];
    array[largestIndex] = temp;

    heapify(array, largestIndex, heapSize);
  }
}

8. 计数排序（Counting Sort）

计数排序是一种非比较排序算法。它的基本思想是：找出数组中最大和最小的元素，然后创建一个大小为最大元素减去最小元素加一的数组，并计算每个元素出现的次数。最后，根据元素出现的次数，将元素按顺序输出到原数组。

function countingSort(array) {
  const min = Math.min(...array);
  const max = Math.max(...array);
  const countArray = new Array(max - min + 1).fill(0);

  for (let i = 0; i < array.