揭秘常见排序算法：分治、交换、比较、插入

2023-10-07 18:05:26

分治算法：快速排序

快速排序是一种高效的分治算法，它利用递归的思想将待排序序列不断分割成更小的子序列，直到每个子序列只有一个元素。在此过程中，算法会选择一个枢轴元素，然后将所有小于枢轴元素的元素放在枢轴元素的左边，所有大于枢轴元素的元素放在枢轴元素的右边。最终，当所有元素都被排序好后，算法将停止。快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。

交换算法：冒泡排序

冒泡排序是一种简单的交换算法，它通过不断比较相邻元素的大小，将较大的元素“冒泡”到序列的末尾。在每趟排序中，算法会遍历整个序列，比较相邻元素的大小，如果前一个元素大于后一个元素，则将它们交换位置。经过多次遍历后，所有元素都会被排序好。冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

比较算法：选择排序

选择排序是一种简单的比较算法，它通过不断选择序列中最小（或最大）的元素，并将其交换到序列的开头（或结尾）。在每趟排序中，算法会遍历整个序列，找到最小（或最大）的元素，然后将其与序列的第一个（或最后一个）元素交换位置。经过多次遍历后，所有元素都会被排序好。选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

插入算法：插入排序

插入排序是一种简单的插入算法，它通过不断将一个元素插入到已经排序好的序列中，来实现排序。在每趟排序中，算法会从第二个元素开始，将其与前面已经排序好的元素比较，如果当前元素小于前面的元素，则将其插入到前面元素的前面。经过多次遍历后，所有元素都会被排序好。插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

算法比较

排序算法的选择取决于数据量大小、数据分布和所需的排序速度等因素。快速排序通常是最快的排序算法之一，但它对数据分布比较敏感，当数据分布不均匀时，它的效率会降低。冒泡排序和选择排序都是简单的排序算法，它们很容易理解和实现，但它们的时间复杂度较高。插入排序对于小数据量或者已经基本有序的数据非常高效。

编程实现

// 快速排序
function quickSort(array) {
  if (array.length <= 1) {
    return array;
  }
  const pivot = array[Math.floor(array.length / 2)];
  const left = [];
  const 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));
}

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

// 选择排序
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;
      }
    }
    const temp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = temp;
  }
  return array;
}

// 插入排序
function insertionSort(array) {
  for (let i = 1; i < array.length; i++) {
    const 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;
}