探秘JavaScript经典排序算法：实现、复杂度、应用与示例代码

2023-12-20 08:39:07

排序算法指南：深入理解经典排序算法

在计算机科学领域，排序算法是解决有序问题必不可少的工具。它将无序的数据集合重新排列成符合特定规则的有序序列。掌握排序算法对于优化程序性能至关重要。

冒泡排序

冒泡排序是一种直观的算法，它将较大元素“冒泡”到数组末尾，从而实现排序。它通过比较相邻元素并交换不满足排序规则的元素来执行此操作。

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

尽管简单，但冒泡排序的效率相对较低，最坏情况下时间复杂度为 O(n^2)，最好情况下为 O(n)。因此，仅适用于数据量较小的场景。

选择排序

选择排序是一种简单的算法，它通过不断选择最小的元素并将其放置在数组开头来实现排序。与冒泡排序类似，它也是通过比较元素来进行。

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

选择排序的时间复杂度与冒泡排序相同，为 O(n^2)。它也适用于数据量较小的场景，因为它的空间复杂度为 O(1)。

快速排序

快速排序是一种分治算法，它将数组划分为两个子数组并递归地对它们进行排序。它通过选择一个枢轴元素来执行此操作，并将数组分成小于或大于枢轴的两个部分。

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

  let pivot = array[Math.floor(array.length / 2)];
  let left = [];
  let right = [];

  for (let i = 0; i < array.length; i++) {
    if (array[i] < pivot) {
      left.push(array[i]);
    } else if (array[i] > pivot) {
      right.push(array[i]);
    }
  }

  return quickSort(left).concat(pivot, quickSort(right));
}

快速排序具有平均时间复杂度 O(nlogn)，最坏情况下为 O(n^2)。它适用于数据量较大且对性能要求较高的场景。

归并排序

归并排序也是一种分治算法，它将数组划分为两个子数组并递归地对它们进行排序。与快速排序不同的是，它在合并子数组之前对它们进行排序。

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

  let mid = Math.floor(array.length / 2);
  let left = mergeSort(array.slice(0, mid));
  let right = mergeSort(array.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let 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(nlogn) 的时间复杂度和 O(n) 的空间复杂度。它适用于数据量较大且需要稳定排序的场景。

插入排序

插入排序是一种简单的算法，它将元素依次插入到已经排好序的子数组中。它通过将元素与前面的元素进行比较并进行交换来执行此操作。

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

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

    array[j + 1] = current;
  }

  return array;
}

插入排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)。它适用于数据量较小或已经部分有序的场景。

希尔排序

希尔排序是插入排序的改进版本，它通过将数组划分为多个子数组并对它们进行插入排序来执行。它通过逐渐减少子数组的大小来提高效率。

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

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

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

      array[j + gap] = current;
    }

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

  return array;
}