剖析常见排序算法：融会贯通，运筹帷幄

前端

2024-01-13 11:54:27

引言

排序算法是计算机科学中的一类重要算法，它们用于对数据进行重新排列，使其满足某种特定顺序。排序算法在各种各样的领域都有着广泛的应用，例如数据库管理、数据挖掘、搜索引擎等。

常见的排序算法

在众多的排序算法中，最常见的包括：

冒泡排序
选择排序
插入排序
希尔排序
归并排序
快速排序
堆排序

排序算法的比较

排序算法的性能通常用时间复杂度和空间复杂度来衡量。时间复杂度是指算法执行所需的时间，空间复杂度是指算法执行所需的空间。

下表对常见的排序算法进行了比较：

排序算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(1)	稳定
希尔排序	O(n log n)	O(1)	不稳定
归并排序	O(n log n)	O(n)	稳定
快速排序	O(n log n)	O(log n)	不稳定
堆排序	O(n log n)	O(1)	不稳定

排序算法的应用场景

不同的排序算法有不同的应用场景。

冒泡排序和选择排序适用于数据量较小的情况。
插入排序适用于数据量较小且数据已经部分有序的情况。
希尔排序适用于数据量较大且数据已经部分有序的情况。
归并排序和快速排序适用于数据量较大且数据无序的情况。
堆排序适用于数据量较大且需要频繁插入和删除元素的情况。

JavaScript 代码实现

以下是用 JavaScript 实现的归并排序、快速排序和堆排序的代码：

// 归并排序
function mergeSort(array) {
  if (array.length <= 1) {
    return array;
  }

  const middle = Math.floor(array.length / 2);
  const left = array.slice(0, middle);
  const right = array.slice(middle);

  return merge(mergeSort(left), mergeSort(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;
}

// 快速排序
function quickSort(array) {
  if (array.length <= 1) {
    return array;
  }

  const pivot = array[0];
  const left = [];
  const right = [];

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

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

// 堆排序
function heapSort(array) {
  function buildMaxHeap(array) {
    for (let i = Math.floor(array.length / 2) - 1; i >= 0; i--) {
      maxHeapify(array, i, array.length);
    }
  }

  function maxHeapify(array, i, size) {
    const left = 2 * i + 1;
    const right = 2 * i + 2;
    let largest = i;

    if (left < size && array[left] > array[largest]) {
      largest = left;
    }

    if (right < size && array[right] > array[largest]) {
      largest = right;
    }

    if (largest !== i) {
      const temp = array[i];
      array[i] = array[largest];
      array[largest] = temp;
      maxHeapify(array, largest, size);
    }
  }

  buildMaxHeap(array);

  for (let i = array.length - 1; i > 0; i--) {
    const temp = array[0];
    array[0] = array[i];
    array[i] = temp;
    maxHeapify(array, 0, i);
  }

  return array;
}