SkyBlog

排序

经典排序算法

下面都是将整数数组排序为升序

// 使用到的原地交换方法
const swap = (nums: number[], i: number, j: number) => {
  ;[nums[i], nums[j]] = [nums[j], nums[i]]
}

冒泡排序(Bubble Sort)

通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样,因此得名冒泡排序。

const bubbleSort = (nums: number[]) => {
  for (let i = nums.length - 1; i > 0; i--) {
    for (let j = 0; j < i; j++) {
      if (nums[j] > nums[j + 1]) {
        swap(nums, j, j + 1)
      }
    }
  }
}

选择排序(Selection Sort)

从未排序区间查找最小的元素,将其放到已排序区间的末尾。

const selectionSort = (nums: number[]) => {
  for (let i = 0; i < nums.length - 1; i++) {
    let k = i
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[j] < nums[k]) {
        k = j
      }
    }
    swap(nums, i, k)
  }
}

插入排序(Insertion Sort)

逐个将元素插入已排序部分,形成新的有序列表。

const insertionSort = (nums: number[]) => {
  for (let i = 1; i < nums.length; i++) {
    const base = nums[i]
    let j = i - 1
    while (j >= 0 && nums[j] > base) {
      nums[j + 1] = nums[j]
      j--
    }
    nums[j + 1] = base
  }
}

快速排序(Quick Sort)

选择一个基准元素,将列表分为两个子列表,小于基准的放在左边,大于基准的放在右边,然后对两个子列表递归地应用相同的方法。

// 交换元素使返回索引 i 满足 nums[a] <= nums[i] <= nums[b] (a∈[left,i]; b∈[i,right]; nums[i]==nums[left])
const partition = (nums: number[], left: number, right: number): number => {
  // 以 nums[left] 为基准数;优化可以先选择几个数把中位数交换到 left 位置上,使交换后左右数量尽可能平均
  let [i, j] = [left, right]
  while (i < j) {
    while (i < j && nums[j] >= nums[left]) j-- // 这两个 while 在这种含等号循环条件下不能交换顺序;
    while (i < j && nums[i] <= nums[left]) i++ // 因为外层 while 循环结束时(i==j),还会交换 nums[left] 与 nums[i],需满足 nums[i] <= nums[left] 才行
    swap(nums, i, j)
  }
  swap(nums, left, i)
  return i
}
 
const quickSort = (nums: number[], left: number, right: number) => {
  if (left >= right) return
  const pivot = partition(nums, left, right)
  quickSort(nums, left, pivot - 1)
  quickSort(nums, pivot + 1, right)
}

三路快排

const partition = (nums: number[], left: number, right: number): [number, number] => {
  let [l, r, i] = [left, right, left + 1]
  const pivot = nums[left]
  while (i <= r) {
    if (nums[i] < pivot) swap(nums, i++, l++)
    else if (nums[i] > pivot) swap(nums, i, r--)
    else i++
  }
  return [l, r]
}
 
const quickSort3Way = (nums: number[], left: number, right: number) => {
  if (left >= right) return
  const [l, r] = partition(nums, left, right)
  quickSort3Way(nums, left, l - 1)
  quickSort3Way(nums, r + 1, right)
}

归并排序(Merge Sort)

一种基于分治策略的排序算法:

  • 划分阶段:通过递归不断地将数组从中点处分开,将长数组的排序问题转换为短数组的排序问题。
  • 合并阶段:当子数组长度为 1 时终止划分,开始合并,持续地将左右两个较短的有序数组合并为一个较长的有序数组,直至结束。
const merge = (nums: number[], left: number, mid: number, right: number) => {
  const tmp = new Array<number>(right - left + 1)
  let [i, j, k] = [left, mid + 1, 0]
  while (i <= mid && j <= right) tmp[k++] = nums[i] <= nums[j] ? nums[i++] : nums[j++]
  // 将左子数组和右子数组的剩余元素复制到临时数组中
  while (i <= mid) tmp[k++] = nums[i++]
  while (j <= right) tmp[k++] = nums[j++]
  // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间
  for (k = 0; k < tmp.length; k++) nums[left + k] = tmp[k]
}
 
const mergeSort = (nums: number[], left: number, right: number) => {
  if (left >= right) return
  const mid = (left + right) >> 1
  mergeSort(nums, left, mid)
  mergeSort(nums, mid + 1, right)
  merge(nums, left, mid, right)
}

堆排序(Heap Sort)

利用堆数据结构,将列表转换为最大堆(最小堆),然后每次从堆顶取出最大(最小)元素,重新调整堆结构。

// 堆的长度为 len,从节点 i 开始,从顶至底堆化
const ajustHeap = (nums: number[], i: number, len: number) => {
  while (true) {
    const [l, r] = [2 * i + 1, 2 * i + 2] // 左右节点索引
    let max = i // 记录根与左右子节点中最大值的索引
    if (l < len && nums[l] > nums[max]) max = l
    if (r < len && nums[r] > nums[max]) max = r
    // 若节点 i 最大或索引 l, r 越界,则无须继续堆化,跳出
    if (max == i) break
    swap(nums, i, max)
    i = max
  }
}
 
const heapSort = (nums: number[]) => {
  for (let i = (nums.length >> 1) - 1; i >= 0; i--) ajustHeap(nums, i, nums.length) // 建堆操作(从树的倒数第二层最后一个元素开始)
  for (let i = nums.length - 1; i > 0; i--) {
    swap(nums, 0, i)
    ajustHeap(nums, 0, i) // 以根节点为起点,从顶至底进行堆化
  }
}

前述几种排序算法都属于“基于比较的排序算法”,它们通过比较元素间的大小来实现排序,此类排序算法的时间复杂度无法超越 O(nlogn)。下面几种“非比较排序算法”,它们的时间复杂度可以在理想情况下达到线性阶。

桶排序(Bucket Sort)

它通过设置一些具有大小顺序的桶,每个桶对应一个数据范围,将数据分配到各个桶中;然后在每个桶内部分别执行排序(语言自带的排序方法);最终按照桶的顺序将所有数据合并。 桶排序适用于处理体量很大的数据。
桶排序的时间复杂度理论上可以达到 O(n),关键在于将元素均匀分配到各个桶中,因为实际数据往往不是均匀分布的。

计数排序(Counting Sort)

统计每个元素的出现次数,然后按照统计信息重建排序后的列表。
适用于数据量大但数据范围较小的整数数组。

const countingSort = (nums: number[]) => {
  // 找到最大值
  const max = Math.max(...nums)
  // 统计各数字的出现次数
  const counter = new Array<number>(max + 1).fill(0)
  for (const num of nums) counter[num]++
  // 求 counter 的前缀和,将“出现次数”转换为“尾索引”;即 counter[num]-1 是 num 在 ans 中最后一次出现的索引
  for (let i = 0; i < max; i++) counter[i + 1] += counter[i]
  // 倒序遍历 nums ,将各元素填入结果数组 ans。倒序遍历 nums 可以避免改变相等元素之间的相对位置,从而实现稳定排序。
  const ans = new Array<number>(nums.length)
  for (let i = nums.length - 1; i >= 0; i--) {
    const num = nums[i]
    ans[--counter[num]] = num
  }
  // 使用结果数组 ans 覆盖原数组 nums
  for (let i = 0; i < nums.length; i++) nums[i] = ans[i]
}

基数排序(Radix Sort)

核心思想与计数排序一致,也通过统计个数来实现排序。在此基础上,基数排序利用数字各位之间的递进关系,依次对每一位进行排序,从而得到最终的排序结果。
适用于数值范围较大的情况,但前提是数据必须可以表示为固定位数的格式,且位数不能过大。

// 获取元素 num 的第 k 位,其中 exp = 10^(k-1),传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
const digit = (num: number, exp: number) => Math.floor(num / exp) % 10
 
// 计数排序(根据 nums 第 k 位排序)
const countingSortDigit = (nums: number[], exp: number) => {
  const counter = new Array(10).fill(0)
  for (let i = 0; i < nums.length; i++) counter[digit(nums[i], exp)]++
  for (let i = 1; i < counter.length; i++) counter[i] += counter[i - 1]
  const ans = new Array<number>(nums.length)
  for (let i = nums.length - 1; i >= 0; i--) {
    const d = digit(nums[i], exp)
    ans[--counter[d]] = nums[i]
  }
  for (let i = 0; i < nums.length; i++) nums[i] = ans[i]
}
 
const radixSort = (nums: number[]) => {
  const max = Math.max(...nums)
  for (let exp = 1; exp <= max; exp *= 10) countingSortDigit(nums, exp)
}