从小白到高手，前端必知的十大排序算法为你保驾护航！

当我们谈论前端技术时，排序算法是一个不可或缺的话题。无论是在数据展示、数据处理还是搜索引擎优化中，排序算法都发挥着至关重要的作用。本文将带领大家深入浅出地剖析十大排序算法，并通过生动形象的示例和清晰易懂的代码讲解，让你对排序算法有一个全面而深刻的理解。

一、冒泡排序：一种简单高效的排序算法

冒泡排序是一种简单而有效的排序算法。它的基本原理是，将相邻的两个元素进行比较，如果前一个元素大于后一个元素，则交换这两个元素的位置，并一直重复这一过程，直到数组中的所有元素都按顺序排列。

冒泡排序代码实现：

function bubbleSort(arr) {
  for (let i = 0; i < arr.length - 1; 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;
}

二、选择排序：通过不断选择最小值进行排序

选择排序是一种通过不断选择最小值进行排序的算法。它的基本原理是，首先找到数组中最小的元素，然后将其与数组的第一个元素交换位置，然后继续寻找数组中剩下的元素中的最小元素，并将其与数组的第二个元素交换位置，以此类推，直到将数组中的所有元素按顺序排列。

选择排序代码实现：

function selectionSort(arr) {
  for (let i = 0; i < arr.length - 1; 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 currentElement = arr[i];
    let j;
    for (j = i - 1; j >= 0 && currentElement < arr[j]; j--) {
      arr[j + 1] = arr[j];
    }
    arr[j + 1] = currentElement;
  }
  return arr;
}

四、快速排序：一种高效的排序算法

快速排序是一种高效的排序算法。它的基本原理是，首先选择数组中的一个元素作为枢轴元素，然后将数组中的元素分为两部分，一部分是小于枢轴元素的元素，另一部分是大于枢轴元素的元素，然后对这两部分分别进行快速排序，最后将两部分合并在一起即可。

快速排序代码实现：

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let pivot = arr[0];
  let left = [];
  let 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).concat(pivot, quickSort(right));
}

五、堆排序：一种基于堆数据结构的排序算法

堆排序是一种基于堆数据结构的排序算法。它的基本原理是，首先将数组中的元素构建成一个堆，然后从堆中取出最大的元素，将其与堆的最后一个元素交换位置，然后重新调整堆的结构，直到堆中只剩下一个元素。

堆排序代码实现：

function heapSort(arr) {
  function buildMaxHeap(arr) {
    for (let i = Math.floor(arr.length / 2 - 1); i >= 0; i--) {
      heapify(arr, i);
    }
  }
  function heapify(arr, i) {
    let largest = i;
    let left = 2 * i + 1;
    let right = 2 * i + 2;
    if (left < arr.length && arr[left] > arr[largest]) {
      largest = left;
    }
    if (right < arr.length && arr[right] > arr[largest]) {
      largest = right;
    }
    if (largest != i) {
      [arr[i], arr[largest]] = [arr[largest], arr[i]];
      heapify(arr, largest);
    }
  }
  buildMaxHeap(arr);
  for (let i = arr.length - 1; i >= 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]];
    heapify(arr, 0);
  }
  return arr;
}