赋能技术升级：探索十大经典排序算法（JavaScript版）

2024-02-08 22:36:43

导语：

在编程世界里，排序算法是数据处理的基本功之一。它们是用来对一组数据进行排列，使其满足某种特定的顺序，如从小到大或从大到小。随着数据量的不断增长，高效的排序算法显得尤为重要。本文将带领读者领略十大经典排序算法的魅力，探寻其背后的奥秘，并在JavaScript中亲身体验它们的实现过程。

一、冒泡排序：

冒泡排序是入门级的排序算法，它通过不断比较相邻元素，将较大的元素逐渐移动到末尾。在每轮比较中，若遇到逆序的元素对，则交换它们的位置。这种比较和交换的过程会持续进行，直至所有元素都按照顺序排列。

1. 优点：

实现简单，易于理解。
空间复杂度低，仅需要常数级别的额外空间。

2. 缺点：

时间复杂度较高，为O(n^2)，当数据量较大时，算法效率低下。

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

const unsortedArray = [5, 3, 1, 2, 4];
const sortedArray = bubbleSort(unsortedArray);
console.log(sortedArray); // Output: [1, 2, 3, 4, 5]

二、选择排序：

选择排序是一种简单有效的排序算法，它通过不断选择最小的元素，将其交换到数组的前部。在每轮选择中，算法从剩余元素中找到最小的元素，并将其与当前位置的元素交换。这种选择和交换的过程会持续进行，直至所有元素都按照顺序排列。

1. 优点：

实现简单，易于理解。
时间复杂度为O(n^2)，与冒泡排序相同，但常数因子更小，因此在某些情况下可能更有效率。
空间复杂度低，仅需要常数级别的额外空间。

2. 缺点：

时间复杂度较高，当数据量较大时，算法效率低下。

3. JavaScript代码示例：

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;
      }
    }
    if (minIndex !== i) {
      let temp = arr[i];
      arr[i] = arr[minIndex];
      arr[minIndex] = temp;
    }
  }
  return arr;
}

const unsortedArray = [5, 3, 1, 2, 4];
const sortedArray = selectionSort(unsortedArray);
console.log(sortedArray); // Output: [1, 2, 3, 4, 5]

三、插入排序：

插入排序是一种简单高效的排序算法，它通过逐个插入元素到已排序的子数组中来完成排序。在每轮插入中，算法从剩余元素中选择一个元素，并在已排序的子数组中找到其合适的位置，将其插入到该位置。这种插入的过程会持续进行，直至所有元素都按照顺序排列。

1. 优点：

实现简单，易于理解。
时间复杂度为O(n^2)，与冒泡排序和选择排序相同，但常数因子更小，因此在某些情况下可能更有效率。
空间复杂度低，仅需要常数级别的额外空间。

2. 缺点：

时间复杂度较高，当数据量较大时，算法效率低下。

3. JavaScript代码示例：

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

const unsortedArray = [5, 3, 1, 2, 4];
const sortedArray = insertionSort(unsortedArray);
console.log(sortedArray); // Output: [1, 2, 3, 4, 5]

四、希尔排序：

希尔排序是一种基于插入排序的改进算法，它通过引入一个间隔值（称为希尔间隔）来减少比较和交换的次数。希尔排序先将数组分成多个子数组，每个子数组的元素间隔为希尔间隔。然后，对每个子数组进行插入排序。随着希尔间隔逐渐缩小，子数组逐渐合并，最终实现对整个数组的排序。

1. 优点：

时间复杂度为O(n log n)，在某些情况下比插入排序和选择排序更有效率。
空间复杂度低，仅需要常数级别的额外空间。

2. 缺点：

实现难度比插入排序和选择排序更大。

3. JavaScript代码示例：

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

  while (gap > 0) {
    for (let i = gap; i < arr.length; i++) {
      let currentElement = arr[i];
      let j;
      for (j = i - gap; j >= 0 && currentElement < arr[j]; j -= gap) {
        arr[j + gap] = arr[j];
      }
      arr[j + gap] = currentElement;
    }
    gap = Math.floor(gap / 2);
  }
  return arr;
}

const unsortedArray = [5, 3, 1, 2, 4];
const sortedArray = shellSort(unsortedArray);
console.log(sortedArray); // Output: [1, 2, 3, 4, 5]

五、快速排序：

快速排序是一种分治排序算法，它通过选取一个基准元素，将数组分为两个子数组，然后递归地对两个子数组进行快速排序。在每轮快速排序中，算法首先选择一个基准元素，然后将数组中的元素分为两部分：小于基准元素的部分和大于基准元素的部分。随后，对两部分分别进行递归排序。这种分治的思想使得快速排序在平均情况下具有极高的效率。

1. 优点：

时间复杂度为O(n log n)，在平均情况下非常高效。
空间复杂度为O(log n)，因为递归调用只使用了常数级别的额外空间。

2. 缺点：

在最坏情况下，时间复杂度退化为O(n^2)，例如当数组已经按顺序排列时。
实现难度比冒泡排序、选择排序和插入排序更大。

3. JavaScript代码示例：

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