深入浅出，用 JS 轻松掌握数组排序技巧

2023-10-16 04:36:57

探索数组排序的奥秘：从冒泡到快速

在 JavaScript 的广阔世界中，数组是处理有序数据的重要组成部分。巧妙地操作数组的能力是任何开发人员必备的技能，其中排序算法扮演着至关重要的角色。本文将带你踏上数组排序的探险之旅，从简单的冒泡排序到强大的快速排序，逐步揭开其背后的原理、复杂度和适用场景。

冒泡排序：简单易懂的排序

想象一下你正在用肥皂泡清洗一盘脏碗。就像肥皂泡浮到水面上一样，冒泡排序通过反复比较相邻元素，将较大的元素“冒泡”到数组的末尾，最终形成一个有序序列。

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

尽管冒泡排序简单易懂，但它的时间复杂度却令人担忧。对于包含 n 个元素的数组，它需要 O(n^2) 的时间，这意味着随着数组大小的增加，排序时间将呈平方级增长。

选择排序：高效且更胜一筹

如果你不喜欢冒泡排序的缓慢，那么选择排序会是一个更好的选择。它像一个挑剔的顾客，一遍遍地浏览数组，寻找最小的（或最大的）元素，然后将其与数组的第一个（或最后一个）元素交换位置。

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

虽然选择排序比冒泡排序高效，但其时间复杂度仍然是 O(n^2)。不过，对于部分有序或几乎有序的数组，它可以表现得更好。

插入排序：有条不紊的插入

插入排序就像一位勤奋的厨师，小心翼翼地将新食材插入到已经排列好的菜肴中。它从第二个元素开始，将其与前面的元素逐一比较，找到合适的插入位置，将其插入其中，保持数组的有序性。

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

插入排序的时间复杂度也是 O(n^2)，但它的平均时间复杂度比选择排序更低，特别适用于小规模数组或几乎有序的数组。

归并排序：分而治之的霸主

想象一下一支强大的军队，将敌人分割成较小的单位，逐个击破，最终征服整个战场。归并排序就是这样的算法，它将数组拆分成更小的子数组，对这些子数组进行排序，然后再将它们合并成一个有序的整体。

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) {
  const result = [];
  let i = 0;
  let j = 0;

  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      result.push(left[i]);
      i++;
    } else {
      result.push(right[j]);
      j++;
    }
  }

  while (i < left.length) {
    result.push(left[i]);
    i++;
  }

  while (j < right.length) {
    result.push(right[j]);
    j++;
  }

  return result;
}

归并排序以其 O(n log n) 的时间复杂度和 O(n) 的空间复杂度而自豪，使其适用于各种规模的数组排序。

快速排序：闪电般的速度

快速排序就像一位敏捷的决斗者，它选择一个“枢纽”元素，将数组划分为两部分：小于枢纽的元素和大于枢纽的元素。然后，它递归地对这两部分进行排序，最后将排序后的部分合并成一个有序的数组。

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