优化快速排序处理大量重复元素：Lomuto分区方案的挑战与Hoare方案的优势-Python教程-PHP中文网

优化快速排序处理大量重复元素：Lomuto分区方案的挑战与Hoare方案的优势

聖光之護

发布： 2025-11-16 12:30:25

原创

959人浏览过

优化快速排序处理大量重复元素：Lomuto分区方案的挑战与Hoare方案的优势

快速排序在处理大量重复元素时，尤其使用lomuto分区方案，可能退化至o(n^2)。本文将探讨此问题，分析一种通过随机化处理重复元素的策略，并对比原始hoare分区方案如何自然且高效地处理重复元素，指出其在性能上的固有优势，以实现更稳定的排序效率。

快速排序与重复元素挑战

快速排序是一种高效的比较排序算法，其核心思想是“分治”。它通过选择一个“枢轴”（pivot）元素，将数组划分为两部分：一部分包含所有小于枢轴的元素，另一部分包含所有大于枢轴的元素。然后对这两个子数组递归地进行快速排序。理想情况下，枢轴能将数组均匀地分成两半，从而达到O(n log n)的平均时间复杂度。

然而，当数组中存在大量重复元素时，快速排序的性能可能急剧下降。特别是当采用Lomuto分区方案时，如果所有元素都与枢轴相等（例如，一个完全由重复数字组成的数组），Lomuto分区会将所有等于枢轴的元素都归入“小于等于”枢轴的一侧，导致一个分区大小为 1（枢轴本身），另一个分区大小为 n-1。这种极端不平衡的分区会使算法的时间复杂度退化到O(n^2)，与冒泡排序等简单排序算法相近。

随机化分区策略的探讨

针对Lomuto分区方案在处理重复元素时的劣势，一种直观的改进思路是尝试在分区过程中更均匀地分布这些重复元素。例如，当遍历到与枢轴相等的元素时，不将其简单地归入某一侧，而是通过随机判断，将其等概率地视为“小于”或“大于”枢轴，从而将其分散到枢轴的两侧。

以下是这种随机化分区策略的Python代码示例：

import random

def partition_randomized_duplicates(arr: list[int], low: int, high: int) -> int:
  """
  使用随机化策略处理重复元素的分区函数。
  将枢轴放在数组末尾。
  """
  pivot = arr[high] # 选择最后一个元素作为枢轴
  current_index = low # current_index 跟踪小于或等于枢轴的元素的边界

  for i in range(low, high):
    # 如果当前元素小于枢轴，或者当前元素等于枢轴且随机决定将其视为“小于”
    if arr[i] < pivot or (arr[i] == pivot and random.random() < 0.5):
      arr[i], arr[current_index] = arr[current_index], arr[i]
      current_index += 1

  # 将枢轴放到其最终位置
  arr[high], arr[current_index] = arr[current_index], arr[high]

  # 返回分区索引
  return current_index

def quick_sort_randomized_duplicates(arr: list[int], low: int, high: int):
  """
  应用随机化分区策略的快速排序主函数。
  """
  if low < high:
    pi = partition_randomized_duplicates(arr, low, high)
    quick_sort_randomized_duplicates(arr, low, pi - 1)
    quick_sort_randomized_duplicates(arr, pi + 1, high)

# 示例用法
# my_array = [3, 2, 3, 1, 2, 4, 5, 5, 6, 7, 7, 8, 8, 8, 9]
# quick_sort_randomized_duplicates(my_array, 0, len(my_array) - 1)
# print(my_array)

登录后复制

这种方法的核心在于 arr[i] == pivot and random.random() < 0.5 这一条件判断。它试图通过引入随机性来打破重复元素总是偏向一侧的局面，从而期望在统计学意义上获得更平衡的分区。

Hoare分区方案：处理重复元素的固有优势

尽管上述随机化策略在理论上看似合理，但在实际中并不常见。这主要是因为Hoare分区方案（快速排序的原始分区方法）能够自然且高效地处理大量重复元素，而无需额外的随机化逻辑。

快标书AI

10分钟生成投标方案

241

查看详情

Hoare分区方案的工作原理如下：

选择一个枢轴元素（通常是数组的中间元素或第一个元素）。
使用两个指针 i 和 j，i 从数组左端向右移动，j 从数组右端向左移动。
指针 i 寻找第一个大于或等于枢轴的元素。
指针 j 寻找第一个小于或等于枢轴的元素。
如果 i 小于 j，则交换 arr[i] 和 arr[j]。
重复步骤3-5，直到 i 大于或等于 j。此时，j（或 i）就是分区点。

def partition_hoare(arr: list[int], low: int, high: int) -> int:
  """
  Hoare分区方案。
  """
  pivot = arr[low + (high - low) // 2] # 选择中间元素作为枢轴
  i = low - 1
  j = high + 1

  while True:
    i += 1
    while arr[i] < pivot:
      i += 1

    j -= 1
    while arr[j] > pivot:
      j -= 1

    if i >= j:
      return j # 返回分区点

    arr[i], arr[j] = arr[j], arr[i]

def quick_sort_hoare(arr: list[int], low: int, high: int):
  """
  应用Hoare分区方案的快速排序主函数。
  """
  if low < high:
    pi = partition_hoare(arr, low, high)
    # 注意：Hoare分区可能导致枢轴最终不在其最终排序位置，
    # 并且分区点pi可能落在等于枢轴的元素中间。
    # 因此，递归调用可能需要调整，例如 quick_sort_hoare(arr, low, pi) 和 quick_sort_hoare(arr, pi + 1, high)
    # 或者 quick_sort_hoare(arr, low, pi) 和 quick_sort_hoare(arr, pi, high)
    # 这里使用一种常见的处理方式，但具体实现可能因枢轴选择和边界处理而异。
    quick_sort_hoare(arr, low, pi)
    quick_sort_hoare(arr, pi + 1, high)

# 示例用法
# my_array = [3, 2, 3, 1, 2, 4, 5, 5, 6, 7, 7, 8, 8, 8, 9]
# quick_sort_hoare(my_array, 0, len(my_array) - 1)
# print(my_array)

登录后复制

Hoare分区处理重复元素的优势在于： 当 i 指针遇到一个等于枢轴的元素时，它会停止。同样，当 j 指针遇到一个等于枢轴的元素时，它也会停止。如果 i < j，这两个等于枢轴的元素会被交换。这意味着，等于枢轴的元素最终会散布在分区点的两侧，而不是全部集中在某一侧。这种行为自然地实现了重复元素的均匀分布，从而避免了Lomuto方案中不平衡分区的问题，即使在全重复数组的情况下，也能产生相对平衡的分区（例如，将数组分成两半，每半都包含一半的重复元素）。

因此，Hoare分区方案在处理大量重复元素时，其分区效果反而趋于理想，能够保持O(n log n)的平均时间复杂度。虽然它可能导致一些不必要的等值元素交换，但这通常不会显著影响其整体性能。

为什么随机化策略不被广泛使用？

结合上述分析，我们可以理解为什么用户提出的随机化策略不被广泛使用：

Hoare分区方案的鲁棒性： 原始的Hoare分区方案已经能够很好地解决重复元素导致的性能问题，其设计更为简洁和高效。
额外的随机性开销： 引入 random.random() < 0.5 这样的随机判断会增加额外的计算开销，而这种开销在Hoare分区中是不必要的。
更优的替代方案： 对于极端情况，即数组中存在大量重复元素，并且需要最高效率时，更专业的算法是三路快速排序（或称荷兰国旗问题）。三路快速排序将数组划分为三个部分：小于枢轴的元素、等于枢轴的元素和大于枢轴的元素。这种方法能够将所有等于枢轴的元素集中在一起，避免了对它们的进一步排序，从而在处理大量重复元素时达到最优性能。