突破程序员进阶，速速掌握LeetCode排序算法三剑客

2024-01-27 11:23:48

排序算法的进阶之道：快速排序、归并排序和堆排序

作为程序员，排序算法是我们的必备技能。在 LeetCode 上，排序算法问题层出不穷，因此掌握这方面的知识至关重要。本文将带领你深入了解快速排序、归并排序和堆排序这三种最常用的 LeetCode 排序算法。

快速排序：分而治之的典范

快速排序是一种分而治之的算法，它将数组划分为两个部分，左半部分的所有元素都小于右半部分的所有元素。然后，对两个部分分别进行排序，最后合并两个排好序的子数组。

快速排序采用递归的方式实现。递归的终止条件是待排序的子数组只有一个元素或为空，此时子数组显然是排好序的。对于非终止条件，快速排序首先选择一个基准元素（pivot），然后将数组划分为两个子数组，左子数组包含所有小于基准元素的元素，右子数组包含所有大于基准元素的元素。最后，递归地对两个子数组进行排序，并合并两个排序好的子数组，得到排好序的完整数组。

代码示例：

def quick_sort(arr):
  if len(arr) <= 1:
    return arr

  pivot = arr[len(arr) // 2]
  left = [x for x in arr if x < pivot]
  middle = [x for x in arr if x == pivot]
  right = [x for x in arr if x > pivot]

  return quick_sort(left) + middle + quick_sort(right)

归并排序：有序力量的集结

归并排序是一种比较排序算法，它将数组分成两半，对两半分别进行排序，然后将排好序的两半合并起来。归并排序的优势在于它可以保证排序结果稳定，即具有相同键值的元素在排序后的数组中保持原有顺序。

归并排序也采用递归的方式实现。递归的终止条件与快速排序相同，对于非终止条件，归并排序首先将数组分成两半，然后递归地对两个子数组进行排序，最后将两个排序好的子数组合并起来，得到排好序的完整数组。合并过程中，归并排序通过比较两个子数组中当前元素的大小，将较小的元素放入结果数组中，直到某个子数组的元素全部放入结果数组中。

代码示例：

def merge_sort(arr):
  if len(arr) <= 1:
    return arr

  mid = len(arr) // 2
  left_half = merge_sort(arr[:mid])
  right_half = merge_sort(arr[mid:])

  return merge(left_half, right_half)

def merge(left, right):
  merged = []
  left_index = 0
  right_index = 0

  while left_index < len(left) and right_index < len(right):
    if left[left_index] <= right[right_index]:
      merged.append(left[left_index])
      left_index += 1
    else:
      merged.append(right[right_index])
      right_index += 1

  merged.extend(left[left_index:])
  merged.extend(right[right_index:])

  return merged

堆排序：堆积能量，排序如风

堆排序是一种基于二叉堆的数据结构进行排序的算法。堆是一种特殊的二叉树，它满足堆性质，即每个节点的值都大于或等于其左右子节点的值。堆排序的思想是将待排序的数组构建成一个堆，然后不断地从堆中取出最大的元素，并将其放在数组的末尾。这样，经过不断地取出和调整，最终数组就被排序好了。

堆排序的实现过程分为两个阶段：建堆阶段和排序阶段。建堆阶段是将数组构建成一个堆，排序阶段是从堆中不断地取出最大的元素，并将其放在数组的末尾。建堆阶段采用自底向上的方式，从数组的最后一个节点开始，逐层向上调整堆。排序阶段采用自顶向下的方式，从堆的根节点开始，不断地取出最大的元素，并将其放在数组的末尾。

代码示例：

def heap_sort(arr):
  # 建堆
  for i in range(len(arr) // 2 - 1, -1, -1):
    heapify(arr, len(arr), i)

  # 排序
  for i in range(len(arr) - 1, 0, -1):
    arr[i], arr[0] = arr[0], arr[i]  # 交换堆顶元素和最后一个元素
    heapify(arr, i, 0)  # 重新调整堆

def heapify(arr, n, i):
  largest = i  # 假设当前节点是最大节点
  left = 2 * i + 1  # 左子节点
  right = 2 * i + 2  # 右子节点

  # 找出当前节点、左子节点和右子节点中的最大节点
  if left < n and arr[left] > arr[largest]:
    largest = left

  if right < n and arr[right] > arr[largest]:
    largest = right

  # 如果当前节点不是最大节点，交换当前节点和最大节点，并继续调整堆
  if largest != i:
    arr[i], arr[largest] = arr[largest], arr[i]
    heapify(arr, n, largest)