1.1 分治法的核心思想：分割世界
“分而治之”是一种强大而普适的算法设计范式，它将一个难以直接解决的大问题，分解为两个或多个与原问题形式相同、但规模更小的子问题，然后递归地解决这些子问题。当子问题的解被求出后，再将它们合并，从而得到原问题的解。
快速排序是“分而-治之”思想最经典、最纯粹的体现。它的整个生命周期，都围绕着一个核心动作展开：
-
分割（Divide）: 这是快速排序的灵魂。从待排序的数组（或子数组）中，挑选出一个元素，我们称之为**“基准”（Pivot）。然后，重新排列数组中的其他所有元素，使得所有小于基准的元素都被移动到基准的左边，所有大于或等于基准的元素都被移动到基准的右边。这个过程结束时，基准元素本身就已经被安放在了它在最终排序序列中应该在的最终位置**。这个分割操作，被称为分区（Partition）。
-
征服（Conquer）: 在一次成功的“分区”操作后，原来的一个大问题，被巧妙地转化为了两个独立的、规模更小的子问题：
- 递归地对基准左侧的子数组进行快速排序。
- 递归地对基准右侧的子数组进行快速排序。
-
合并（Combine）: 这是快速排序最优雅、最简洁的地方。它的“合并”步骤是微不足道的，甚至可以说是不存在的。因为当左右两个子数组都被递归地排好序之后，由于分区操作已经保证了左边所有元素都小于右边所有元素，整个数组自然而然地就变得有序了。我们什么都不用做。
这种“困难的分割，轻松的合并”的特性，与归并排序（Merge Sort）的“轻松的分割，困难的合并”形成了鲜明的对比，也正是这种特性，赋予了快速排序原地排序（in-place）的强大能力。
1.2 分区机制的精微剖析之一：Lomuto分区方案
“分区”是快速排序算法的心脏，其实现的优劣直接决定了算法的性能。业界存在多种分区方案，我们首先来深入解剖一种广为流传、也更符合直觉的方案——Lomuto分区方案（Lomuto Partition Scheme）。
Lomuto方案的哲学:
Lomuto分区的核心，是维护一个指针 i，这个指针像一个“边界墙”，它将数组划分为两个区域：
- 墙的左边（包括墙本身），是“小于等于基准”的区域。
- 墙的右边，是“尚未处理”或“大于基准”的区域。
算法通过一个移动指针 j 来遍历数组，一旦 j 发现了一个小于等于基准的元素，就将其与“墙”右侧的第一个元素交换，然后将“墙”向右移动一格，从而扩大“小于等于基准”区域的疆土。
纤毫毕现的视觉化追踪 (Lomuto):
让我们用数组 arr = [8, 7, 2, 1, 0, 9, 6]，并选择最后一个元素 6 作为基准（pivot），来细致入微地追踪Lomuto分区的每一步。
初始状态:
arr = [8, 7, 2, 1, 0, 9, 6]
pivot = 6
i = -1 ( i 指向“小于等于区”的最后一个元素，初始时该区域为空)
j 从 0 开始遍历到 n-2。
j = 0, arr[j] = 8:
8 > pivot(6)? 是。什么都不做。i保持-1。数组:[8, 7, 2, 1, 0, 9, 6]
j = 1, arr[j] = 7:
7 > pivot(6)? 是。什么都不做。i保持-1。数组:[8, 7, 2, 1, 0, 9, 6]
j = 2, arr[j] = 2:
2 <= pivot(6)? 是。- 执行操作:
i先自增:i变为0。- 交换
arr[i]和arr[j](即arr[0]和arr[2])。
i = 0。数组变为:[2, 7, 8, 1, 0, 9, 6]
j = 3, arr[j] = 1:
1 <= pivot(6)? 是。- 执行操作:
i先自增:i变为1。- 交换
arr[i]和arr[j](即arr[1]和arr[3])。
i = 1。数组变为:[2, 1, 8, 7, 0, 9, 6]
j = 4, arr[j] = 0:
0 <= pivot(6)? 是。- 执行操作:
i先自增:i变为2。- 交换
arr[i]和arr[j](即arr[2]和arr[4])。
i = 2。数组变为:[2, 1, 0, 7, 8, 9, 6]
j = 5, arr[j] = 9:
9 > pivot(6)? 是。什么都不做。i保持2。数组:[2, 1, 0, 7, 8, 9, 6]
循环结束 (j 遍历完毕)
- 此时
i = 2。arr[0...2]是所有小于等于基准的元素。 - 最后一步: 将基准元素与
arr[i+1]交换，将其安放到最终位置。 - 交换
arr[i+1](即arr[3]) 和arr[6](基准6)。 - 数组变为:
[2, 1, 0, 6, 8, 9, 7] - 基准
6现在位于索引3。分区完成。
Lomuto分区方案的Python实现:
def lomuto_partition(arr, low, high):
"""
Lomuto分区方案的实现。
选择最后一个元素作为基准。
参数:
arr (list): 待分区的列表。
low (int): 子数组的起始索引。
high (int): 子数组的结束索引。
返回:
int: 基准元素分区后所在的最终索引。
"""
pivot = arr[high] # 选择子数组的最后一个元素作为基准
# i 指针用于追踪“小于等于基准”区域的右边界。
# 初始时，这个区域是空的，所以 i 指向 low 的前一个位置。
i = low - 1
# j 指针用于遍历子数组中除基准外的所有元素。
for j in range(low, high):
# 如果当前遍历到的元素小于或等于基准
if arr[j] <= pivot:
# 首先，将“小于等于”区域的边界向右扩展一格。
i += 1
# 然后，将这个小于等于基准的元素 arr[j] 交换到扩展后的区域内。
arr[i], arr[j] = arr[j], arr[i]
# 循环结束后，arr[low...i] 区域的所有元素都小于等于基准。
# i+1 的位置就是基准元素应该在的最终位置。
# 将基准元素交换到这个位置。
arr[i + 1], arr[high] = arr[high], arr[i + 1]
# 返回基准元素的新索引。
return i + 1
def quick_sort_lomuto(arr, low, high):
"""
使用Lomuto分区方案的快速排序递归函数。
参数:
arr (list): 待排序的列表。
low (int): 当前处理的子数组的起始索引。
high (int): 当前处理的子数组的结束索引。
"""
# 递归的基线条件：当子数组至少有两个元素时才进行处理。
if low < high:
# 调用分区函数，对 arr[low...high] 进行分区，
# 并得到基准元素所在的最终位置 pi。
pi = lomuto_partition(arr, low, high)
# 分区后，基准元素 arr[pi] 已经就位。
# 现在，我们递归地对左右两个独立的子数组进行快速排序。
# 递归排序基准左边的子数组。
quick_sort_lomuto(arr, low, pi - 1)
# 递归排序基准右边的子数组。
quick_sort_lomuto(arr, pi + 1, high)
# --- 完整示例的包装函数 ---
def sort_with_lomuto(arr):
"""一个方便调用的包装函数，启动基于Lomuto的快速排序"""
if arr is None or len(arr) < 2:
return
quick_sort_lomuto(arr, 0, len(arr) - 1)
# --- 示例代码 ---
# data_to_sort_lomuto = [8, 7, 2, 1, 0, 9, 6]
# print(f"Lomuto - 原始数据: {data_to_sort_lomuto}")
# sort_with_lomuto(data_to_sort_lomuto)
# print(f"Lomuto - 排序后: {data_to_sort_lomuto}")
1.3 分区机制的精微剖析之二：Hoare分区方案
C. A. R. Hoare，快速排序算法的发明者，他最初提出的分区方案与Lomuto方案有所不同，且在实践中通常效率更高。这就是Hoare分区方案（Hoare Partition Scheme）。
Hoare方案的哲学:
Hoare方案使用两个方向相反的指针，一个从左向右（i），一个从右向左（j），它们像两堵相向而行的墙，试图将数组挤压、分割。
i指针的任务是向右移动，跳过所有小于基准的元素，直到找到一个大于或等于基准的“错位”元素。j指针的任务是向左移动，跳过所有大于基准的元素，直到找到一个小于或等于基准的“错位”元素。- 一旦
i和j都找到了自己的目标，并且i仍然在j的左边，就将arr[i]和arr[j]这两个“错位”的元素进行交换。 - 这个过程不断重复，直到
i和j指针相遇或交错，此时分区完成。
关键区别与注意事项:
- Hoare方案在分区结束后，并不保证返回的索引就是基准元素所在的最终位置。它只保证返回的索引
j左边的所有元素都小于或等于j右边的所有元素。 - 因此，在进行递归调用时，区间的划分与Lomuto方案有所不同。
- Hoare方案平均进行的交换次数比Lomuto方案要少大约三倍，因此通常更快。
纤毫毕现的视觉化追踪 (Hoare):
我们用同样的数组 arr = [8, 7, 2, 1, 0, 9, 6]，并选择第一个元素 8 作为基准（pivot）。
初始状态:
arr = [8, 7, 2, 1, 0, 9, 6]
pivot = 8
i = -1 (将从左边界low的前一个位置开始)
j = 7 (将从右边界high的后一个位置开始)
主循环 1:
- i 指针移动:
i变为0。arr[0](8) < pivot(8)? 否。i停在0。
- j 指针移动:
j变为6。arr[6](6) > pivot(8)? 否。j停在6。
- 检查与交换:
i(0) < j(6)? 是。- 交换
arr[0]和arr[6]。 - 数组变为:
[6, 7, 2, 1, 0, 9, 8]
- 交换
主循环 2:
- i 指针移动:
i变为1。arr[1](7) < pivot(8)? 是。i变为2。arr[2](2) < pivot(8)? 是。i变为3。arr[3](1) < pivot(8)? 是。i变为4。arr[4](0) < pivot(8)? 是。i变为5。arr[5](9) < pivot(8)? 否。i停在5。
- j 指针移动:
j变为5。arr[5](9) > pivot(8)? 是。j变为4。arr[4](0) > pivot(8)? 否。j停在4。
- 检查与交换:
i(5) < j(4)? 否。i和j已经交错。
循环结束:
while循环终止。函数返回j的值，即4。- 分区后的数组:
[6, 7, 2, 1, 0, 9, 8] - 观察:
arr[0...4](即[6, 7, 2, 1, 0]) 都在返回点j的左边（包括j）。arr[5...6](即[9, 8]) 都在返回点j的右边。- 分区是成功的，但基准
8并不在索引4。
Hoare分区方案的Python实现:
def hoare_partition(arr, low, high):
"""
Hoare分区方案的实现。
选择第一个元素作为基准。
参数:
arr (list): 待分区的列表。
low (int): 子数组的起始索引。
high (int): 子数组的结束索引。
返回:
int: 一个分割点的索引 j，使得 arr[low...j] 中的所有元素
都小于或等于 arr[j+1...high] 中的所有元素。
"""
pivot = arr[low] # 选择第一个元素作为基准
i = low - 1 # 左指针，从左边界外侧开始
j = high + 1 # 右指针，从右边界外侧开始
while True:
# i 指针从左向右移动，直到找到一个大于或等于基准的元素。
i += 1
while arr[i] < pivot:
i += 1
# j 指针从右向左移动，直到找到一个小于或等于基准的元素。
j -= 1
while arr[j] > pivot:
j -= 1
# 如果两个指针相遇或交错，说明分区过程已经完成。
if i >= j:
return j # 返回右指针 j 作为分割点
# 如果指针还未交错，交换它们指向的两个“错位”的元素。
arr[i], arr[j] = arr[j], arr[i]
def quick_sort_hoare(arr, low, high):
"""
使用Hoare分区方案的快速排序递归函数。
参数:
arr (list): 待排序的列表。
low (int): 当前处理的子数组的起始索引。
high (int): 当前处理的子数组的结束索引。
"""
if low < high:
# 调用Hoare分区，得到分割点 p。
# 注意：p 不是基准的最终位置。
p = hoare_partition(arr, low, high)
# 递归地对左右两个子数组进行排序。
# 左边子数组的范围是 [low, p]。
# 因为我们不知道 p 是不是基准，所以 p 必须被包含在其中一个递归调用中。
quick_sort_hoare(arr, low, p)
# 右边子数组的范围是 [p+1, high]。
quick_sort_hoare(arr, p + 1, high)
# --- 完整示例的包装函数 ---
def sort_with_hoare(arr):
"""一个方便调用的包装函数，启动基于Hoare的快速排序"""
if arr is None or len(arr) < 2:
return
quick_sort_hoare(arr, 0, len(arr) - 1)
# --- 示例代码 ---
# data_to_sort_hoare = [8, 7, 2, 1, 0, 9, 6]
# print(f"\nHoare - 原始数据: {data_to_sort_hoare}")
# sort_with_hoare(data_to_sort_hoare)
# print(f"Hoare - 排序后: {data_to_sort_hoare}")
Lomuto vs. Hoare 总结:
- 直观性: Lomuto方案更直观，因为它能把基准明确地放到最终位置。
- 效率: Hoare方案在元素交换次数上更胜一筹，通常是实践中的首选。
- 实现细节: 两者在实现递归调用时的区间划分有细微但至关重要的差别，错误地使用区间会导致无限递归。
第二章：双刃剑：快速排序的性能分析与退化之谜
快速排序以其卓越的平均性能——O(n log n)——而闻名于世，这个“快”字可谓名副其实。然而，它也像一把锋利的双刃剑，在某些特定情况下，其性能会灾难性地退化到与插入排序、选择排序同级别的 O(n²)。理解这种性能的“双面性”，并掌握如何驾驭这把双刃剑，是衡量一个程序员是否真正理解快速排序的关键。
2.1 时间复杂度的三维剖析
2.1.1 最佳情况：完美的平衡 (O(n log n))
- 场景: 每次分区操作，都恰好能选中当前子数组的**中位数（Median）**作为基准。
- 行为分析:
- 如果基准总是中位数，那么每一次分区操作都会将当前规模为
k的问题，完美地分割成两个规模几乎相等的子问题，每个子问题的规模约为k/2。 - 分区操作本身，无论是Lomuto还是Hoare方案，都需要遍历整个子数组一次，其成本是
O(k)。
- 如果基准总是中位数，那么每一次分区操作都会将当前规模为
- 计算成本分析:
- 第0层（根节点）：对
n个元素进行分区，成本O(n)。问题变为 2 个n/2的子问题。 - 第1层：对 2 个
n/2的子问题进行分区，总成本2 * O(n/2) = O(n)。问题变为 4 个n/4的子问题。 - 第2层：对 4 个
n/4的子问题进行分区，总成本4 * O(n/4) = O(n)。问题变为 8 个n/8的子问题。 - …
- 这个过程会一直持续下去，直到子问题的规模变为1。这个递归树的高度是多少？从
n不断除以2，直到1，这个次数是log₂(n)。 - 我们有
log n个层级，每个层级的总工作量都是O(n)。
- 第0层（根节点）：对
- 复杂度: 算法的总时间复杂度 = (每个层级的工作量) * (层级数) =
O(n) * O(log n) = O(n log n)。
这是快速排序所能达到的理论最快速度，它体现了“分而治之”策略的极致效率。
2.1.2 平均情况：可接受的不完美 (O(n log n))
- 场景: 基准的选择是随机的，或者说，基准在子数组中的排名是随机的。我们不需要每次都幸运地选中完美的中位数。
- 行为分析:
- 即使我们的分区不是完美的50/50分割，只要它能保持一个相对“合理”的分割比例，例如 10/90 或 25/75，算法的整体性能就不会有数量级上的变化。
- 假设最坏的“合理”分割是，每次都将问题分割成
1/10和9/10的两个子问题。 - 递归树的结构会变得“倾斜”，不再是完美的平衡二叉树。
- 最长的递归路径（沿着
9/10那条路走）的深度会变大，大约是log₁₀/₉(n)。最短的路径深度是log₁₀(n)。虽然树的高度变大了（log₁.₁₁(n) ≈ 10.4 * log₂(n)），但它仍然是log n的数量级。 - 在每一层，总的工作量仍然是
O(n)。
- 复杂度: 经过更严格的概率论和数学分析可以证明，在随机选择基准的假设下，快速排序的期望运行时间是
O(n log n)。其常数因子甚至比许多其他O(n log n)算法还要小，这也是它“快”的另一个原因。
2.1.3 最坏情况：灾难的降临 (O(n²))
- 场景: 每次分区操作，都极其不幸地选中了当前子数组的最小值或最大值作为基准。
- 行为分析:
- 假设我们使用Lomuto分区（以最后一个元素为基准），而输入的数组已经排好序或完全逆序。
- 当数组已排序时（例如
[1, 2, 3, 4, 5]），我们选择5为基准。分区后，arr[0...3]都小于5，右侧子数组为空。问题被分割成一个n-1规模的子问题和一个0规模的子问题。 - 在下一个递归中，对
[1, 2, 3, 4]排序，选择4为基准，同样产生一个n-2的子问题和一个空问题。 - 这个过程持续下去，递归树变成了一条长长的“链条”，完全失去了“分治”的优势。
- 计算成本分析:
- 第1轮：对
n个元素分区，成本O(n)。产生n-1的子问题。 - 第2轮：对
n-1个元素分区，成本O(n-1)。产生n-2的子问题。 - 第3轮：对
n-2个元素分区，成本O(n-2)。 - …
- 总的计算成本是
n + (n-1) + (n-2) + ... + 1。
- 第1轮：对
- 复杂度: 这个等差数列的和是
n * (n+1) / 2，即 O(n²)。
退化的根源:
快速排序性能退化的根本原因，在于分区的极度不平衡。当分区操作无法有效地将问题规模减小（例如，从 n 变为 n-1），“分而治之”就退化成了“减而治之”（Decrease and Conquer），其性能表现与插入排序、选择排序无异。
另一个隐藏的杀手：栈空间溢出
在 O(n²) 的最坏情况下，递归树的深度达到了 O(n)。每一次递归调用，都需要在程序的调用栈（Call Stack）上分配一块空间来存储函数的局部变量、返回地址等信息。如果 n 非常大（例如，几十万），O(n) 的递归深度会消耗大量的栈空间，极有可能导致**栈溢出（Stack Overflow）**错误，使得程序直接崩溃。这是一个比时间超限更严重的问题。
2.2 规避最坏情况：基准选择的艺术
既然最坏情况的根源在于基准选择不当，那么优化的核心就在于如何选择一个“好”的基准。目标是：以较小的代价，选择一个尽可能接近中位数的元素作为基准。
2.2.1 策略一：随机化选择 (Randomized Pivot Selection)
这是最简单、也最常用、最有效的策略之一。
- 思想: 在每次分区前，不再固定地选择第一个或最后一个元素，而是在当前子数组
arr[low...high]中，随机选择一个元素，然后将它与arr[high]（或arr[low]）交换。之后，再像往常一样执行分区算法（例如Lomuto或Hoare）。 - 效果:
- 通过随机化，基准是最大值或最小值的概率变得非常小。无论输入的数组是什么样的（即使是已经排好序的），我们都有很大概率选到一个“不错”的基准。
- 随机化使得算法的性能表现，在概率上独立于输入数据的初始顺序。一个怀有恶意的用户，无法再通过构造一个特定的“坏”数组来攻击我们的排序程序。
- 经过随机化后，快速排序的最坏情况
O(n²)仍然理论上可能发生（如果我们每次都随机选中了最差的基准），但其发生的概率变得微乎其微，可以忽略不计。算法的期望时间复杂度稳定在O(n log n)。
代码实现：改造Lomuto分区
import random
def randomized_partition(arr, low, high):
"""
随机化分区方案。
先随机选择一个元素作为基准，然后使用Lomuto方案进行分区。
"""
# 在 [low, high] 范围内随机选择一个索引
rand_pivot_idx = random.randint(low, high)
# 将随机选中的基准元素与最后一个元素交换
arr[rand_pivot_idx], arr[high] = arr[high], arr[rand_pivot_idx]
# 现在，最后一个元素就是我们的（随机）基准，可以调用标准Lomuto分区
return lomuto_partition(arr, low, high)
def quick_sort_randomized(arr, low, high):
"""
使用随机化分区的快速排序递归函数。
"""
if low < high:
# 使用随机化分区来获取分割点
pi = randomized_partition(arr, low, high)
# 递归调用与之前相同
quick_sort_randomized(arr, low, pi - 1)
quick_sort_randomized(arr, pi + 1, high)
# --- 包装函数 ---
def sort_with_randomized_quicksort(arr):
"""方便调用的包装函数"""
if arr is None or len(arr) < 2:
return
quick_sort_randomized(arr, 0, len(arr) - 1)
# --- 示例 ---
# data_sorted = list(range(10)) # 一个已经排好序的数组，是朴素快速排序的噩梦
# print(f"Randomized - 原始已排序数据: {data_sorted}")
# # 如果不使用随机化，对这个数组排序会导致栈溢出（对于大数组）或O(n^2)时间
# sort_with_randomized_quicksort(data_sorted)
# print(f
最低0.47元/天 解锁文章
扫一扫
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
