前端排序算法的魅力解析

2023-11-30 21:09:32

在前端开发中，排序算法是整理和处理数据的关键工具。它们可以将数据按照特定顺序（如升序或降序）排列，以便于快速检索和高效操作。本文将深入探讨各种前端排序算法的原理和应用，揭示其各自的魅力所在。

sort排序：简洁高效

sort() 方法是 JavaScript 内置的一种通用排序算法，它采用快速排序或归并排序等高效算法来对数组元素进行排序。sort() 的优势在于其简洁性，只需一行代码即可完成排序操作。

const numbers = [5, 2, 1, 4, 3];
numbers.sort(); // [1, 2, 3, 4, 5]

插入排序：稳定性与效率并存

插入排序通过将新元素逐个插入到已排序的部分中，最终达到整体有序的目的。它的优点在于稳定性，即具有相同值的元素在排序后的顺序不会发生改变。同时，插入排序在小规模数据上的效率也较高。

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

冒泡排序：直观易懂

冒泡排序反复遍历数组，逐对比较相邻元素，将较大的元素“冒泡”到后面。该算法的优点在于其直观易懂，实现相对简单。但是，冒泡排序的效率较低，对于大规模数据排序时性能不佳。

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]) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

选择排序：找出最优

选择排序通过在未排序的部分中找出最小（或最大）的元素，并将其与未排序部分的第一个元素交换，以此类推，直到所有元素有序。选择排序的优点在于其稳定性，但其效率低于插入排序和冒泡排序。

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;
      }
    }
    const temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
}

桶排序：分而治之

桶排序将待排序的数据分成若干个相等大小的桶，然后将每个元素分配到对应的桶中。每个桶内再使用其他排序算法（如插入排序）进行排序，最后将各个桶中的元素连接起来即可。桶排序的优点在于其效率较高，适用于数据范围较大的排序场景。

function bucketSort(arr) {
  const minValue = Math.min(...arr);
  const maxValue = Math.max(...arr);
  const bucketCount = 5; // 桶的数量
  const bucketSize = (maxValue - minValue) / bucketCount;

  const buckets = [];
  for (let i = 0; i < bucketCount; i++) {
    buckets.push([]);
  }

  for (let i = 0; i < arr.length; i++) {
    const bucketIndex = Math.floor((arr[i] - minValue) / bucketSize);
    buckets[bucketIndex].push(arr[i]);
  }

  for (let i = 0; i < bucketCount; i++) {
    buckets[i].sort();
  }

  const sortedArray = [];
  for (let i = 0; i < bucketCount; i++) {
    sortedArray.push(...buckets[i]);
  }

  return sortedArray;
}

希尔排序：结合插入排序和归并排序

希尔排序将数组分成多个子数组，每个子数组再使用插入排序进行排序。随着子数组的长度不断缩小，希尔排序逐渐将数组中的元素有序化。希尔排序的优点在于其效率比插入排序和冒泡排序高，但低于快速排序和归并排序。

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

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

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

快速排序：高效分而治之

快速排序是一种高效的分而治之排序算法。它通过选取一个基准元素，将数组分成比基准元素小和大的两个部分，再对这两个部分递归地应用快速排序，最终将整个数组排序完成。快速排序的优点在于其效率非常高，但其稳定性不如插入排序。

function quickSort(arr, left, right) {
  if (left < right) {
    const partitionIndex = partition(arr, left, right);

    quickSort(arr, left, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, right);
  }

  function partition(arr, left, right) {
    const pivot = arr[right];
    let i = left - 1;

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

    const temp = arr[i + 1];
    arr[i + 1] = arr[right];
    arr[right] = temp;

    return i + 1;
  }
}