快速排序（Quicksort）是由计算机科学家 C.A.R. Hoare 在 1960 年提出的一种高效的、基于比较的排序算法。在计算机科学领域，快速排序以其出色的平均性能而闻名，是算法学习和实际应用中必须掌握的核心算法之一。本文将从其基本原理出发，深入探讨其实现、性能分析、优化策略以及在现代编程语言中的实际应用。
一、核心思想：分而治之（Divide and Conquer）
快速排序完美地体现了分而治之的算法思想。与归并排序类似，它也将一个大问题分解为多个小问题来解决，但其分解和合并的方式独具特色。
其核心步骤如下：
分解（Divide） ：在待排序的数组（或子数组）中，选择一个元素作为**"枢轴"（Pivot）**。然后，重新排列数组，将所有小于枢轴的元素移动到枢轴的左侧，所有大于等于枢轴的元素移动到右侧。完成这一步后，枢轴就位于其最终排序位置上。这个过程称为 分区（Partition）。
解决（Conquer）：通过递归调用，对枢轴左侧和右侧的两个子数组分别进行快速排序。
合并（Combine）：由于子数组都是**原地（in-place）**排序的，当递归过程结束时，整个数组就已经有序。因此，快速排序的合并步骤是平凡的，无需任何操作。
与归并排序的"先递归，后合并"不同，快速排序的核心工作（分区）发生在递归调用之前，这使得它的合并阶段极为简单。
二、关键操作：分区（Partition）
分区是快速排序的灵魂。一个高效的分区方案是整个算法性能的关键。这里我们介绍最经典的分区实现之一：Lomuto 分区方案。
Lomuto 分区方案通常选择数组的最后一个元素作为枢轴。它维护一个指针 i，这个指针的左边（包括 i）是所有已经处理过的小于等于枢轴的元素。
步骤如下：
选择数组 A 的最后一个元素 A[high] 作为枢轴 pivot。
初始化一个索引 i 为 low - 1。这个 i 可以看作是"小于枢轴"区域的右边界。
用另一个指针 j 从 low 遍历到 high - 1：
如果 A[j] 小于等于 pivot，则将 i 右移一位（i++），然后交换 A[i] 和 A[j]。这相当于将小的元素 A[j] 放入"小于枢轴"的区域。
遍历结束后，i+1 的位置就是枢轴的最终正确位置。交换 A[i+1] 和枢轴 A[high]。
返回枢轴的新索引 i+1。
图解示例：
对数组 [4, 7, 2, 1, 8, 5] 进行分区，选择 5 作为枢轴。
low = 0, high = 5, pivot = 5
i = -1
j
Aj <= pivot
操作
i
数组状态
0
A0=4 <= 5
i=0, swap(A0, A0)
0
[4, 7, 2, 1, 8, 5]
1
A1=7 > 5
(无)
0
[4, 7, 2, 1, 8, 5]
2
A2=2 <= 5
i=1, swap(A1, A2)
1
[4, 2, 7, 1, 8, 5]
3
A3=1 <= 5
i=2, swap(A2, A3)
2
[4, 2, 1, 7, 8, 5]
4
A4=8 > 5
(无)
2
[4, 2, 1, 7, 8, 5]
循环结束。交换 A[i+1] (即 A[3]) 和 A[high] (即 A[5])。
swap(A[3], A[5]) -> swap(7, 5)
最终数组为：[4, 2, 1, 5, 8, 7]
返回枢轴的新索引 3。此时，5 左边的元素都比它小，右边的都比它大。
三、算法实现（类C语言）
下面是使用 C 语言实现的快速排序算法，采用了 Lomuto 分区方案。
c
复制代码
#include
// 交换两个元素的辅助函数
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
/*
* Lomuto 分区方案
* @param arr 待分区的数组
* @param low 起始索引
* @param high 结束索引
* @return 枢轴的最终位置
*/
int partition(int arr[], int low, int high) {
// 选择最后一个元素作为枢轴
int pivot = arr[high];
// i 是小于枢轴区域的右边界
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
// 如果当前元素小于或等于枢轴
if (arr[j] <= pivot) {
i++; // 扩展小于枢轴的区域
swap(&arr[i], &arr[j]);
}
}
// 将枢轴放到其正确的位置
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
/*
* 快速排序主函数
* @param arr 待排序的数组
* @param low 起始索引
* @param high 结束索引
*/
void quickSort(int arr[], int low, int high) {
if (low < high) {
// pi 是分区后枢轴的索引
int pi = partition(arr, low, high);
// 分别对枢轴左右两边的子数组进行排序
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 打印数组的辅助函数
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, n);
quickSort(arr, 0, n - 1);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
四、算法分析
1. 时间复杂度
快速排序的性能高度依赖于枢轴的选择。
最佳情况（Best Case）：O(n log n)
当每次分区操作都能将数组平分为两个大小几乎相等的子数组时，达到最佳情况。此时的递归树深度为 O(log n)，每层递归的分区操作总共需要 O(n) 的时间。因此总时间复杂度为 O(n log n)。
其递推关系式为：T(n) = 2T(n/2) + O(n)。
平均情况（Average Case）：O(n log n)
在大多数情况下，即使分区不是完全平均的（例如，每次都分成 1/10 和 9/10 的比例），递归树的深度也保持在 O(log n) 级别。可以从数学上证明，在枢轴随机选择的假设下，其期望时间复杂度为 O(n log n)。这是快速排序在实践中表现出色的主要原因。
最坏情况（Worst Case）：O(n²)
最坏情况发生在每次选择的枢轴都是当前数组中的最大或最小元素时。例如，对一个已经排序好或逆序排序的数组使用固定的枢轴选择策略（如选择第一个或最后一个元素）。这会导致分区极度不平衡，一个子数组大小为 0，另一个为 n-1。
其递推关系式为：T(n) = T(n-1) + O(n)，解得 T(n) = O(n²)。
2. 空间复杂度
平均情况：O(log n)
空间复杂度主要由递归调用栈的深度决定。在平均情况下，递归树的深度为 O(log n)。
最坏情况：O(n)
在最坏情况下，递归深度达到 O(n)，可能导致栈溢出（Stack Overflow）。
3. 稳定性
快速排序是一种不稳定 的排序算法。在分区过程中，相等元素的相对顺序可能会被改变。例如，对于数组 [5a, 3, 5b, 2]，如果选择 3 作为枢轴，5a 和 5b 的相对位置不变。但如果选择 5a 作为枢轴，在分区交换过程中，5b 很可能被移动到 5a 的前面。
五、快速排序的优化策略
为了克服最坏情况并提升整体性能，实际应用中的快速排序通常会包含以下优化：
1. 枢轴选择优化
这是最重要的优化，旨在避免 O(n²) 的最坏情况。
三数取中法（Median-of-Three） ：从数组的 low, mid, high 三个位置选择元素，取其中值作为枢轴。这能有效避免在有序或接近有序数组上性能退化的问题。
随机化选择：随机从子数组中选取一个元素作为枢轴。这使得最坏情况的发生概率变得极低，让算法的性能表现稳定在期望的 O(n log n)。
2. 小数组优化
当递归到子数组的规模非常小时（例如，长度小于 10-20），递归调用的开销会变得相对较大。此时，可以切换到插入排序。插入排序在处理小规模或基本有序数组时效率非常高。
3. 递归优化
尾递归优化：在分区后，我们有两个子问题需要递归解决。可以优先对较短的那个子数组进行递归，这能保证递归栈的深度最大为 O(log n)，有效避免了最坏情况下的栈溢出问题。
迭代实现：通过使用一个显式的栈（Stack）来模拟递归过程，可以完全避免系统调用栈的限制。
4. 三路快排（3-Way Quicksort）
当数组中存在大量重复元素时，标准的二路分区效率会降低。例如，对于一个所有元素都相等的数组，算法会退化到 O(n²)。
三路快排将数组分为三部分：< pivot，== pivot，> pivot。之后，只需对 < pivot 和 > pivot 的部分进行递归排序。这种方法由 Edsger Dijkstra 提出，也被称为荷兰国旗问题，它对于处理含大量重复键值的数组非常高效。
六、实际应用与语言内置实现
快速排序因其卓越的平均性能和原地排序的特性，在系统级排序中被广泛应用。
那么，我们常用的编程语言内置的 sort 函数是快速排序吗？
答案是：不完全是，通常是更先进的混合排序算法。
C++ std::sort ：通常实现为 Introsort（内省排序） 。Introsort 以快速排序开始，但会监测递归深度。如果深度超过某个阈值（通常是 O(log n)），它会切换到堆排序（Heapsort） ，从而保证最坏情况下的时间复杂度为 O(n log n)。对于小数组，它同样会切换到插入排序。
Java Arrays.sort：
对于基本数据类型 （如 int, float），它使用的是一种高度优化的双轴快速排序（Dual-Pivot Quicksort）。这种算法选择两个枢轴，将数组分为三部分，实践证明比传统快排有更好的性能。
对于对象类型 ，它使用的是 Timsort。Timsort 是一种结合了归并排序和插入排序的稳定排序算法，它在处理部分有序的数据时表现极为出色。
Python sort() 和 sorted() ：与 Java 的对象排序类似，Python 使用的也是 Timsort 。选择 Timsort 的主要原因是其稳定性和在真实世界数据（通常包含有序子序列）上的优异性能。
C 语言 qsort() ：C 标准库中的 qsort 函数虽然名字来源于 Quicksort，但标准并未规定其必须使用快速排序实现。不过，大多数高质量的 C 库实现（如 glibc）确实是基于经过优化的快速排序。
七、总结
快速排序无疑是算法史上的一座丰碑。它向我们展示了"分而治之"思想的强大威力。
优点：
极高的平均效率：O(n log n) 的平均时间复杂度在同类算法中首屈一指。
原地排序：仅需 O(log n) 的辅助栈空间，空间效率高。
缺点：
最坏情况性能差：未经优化的版本在特定数据下会退化到 O(n²)。
不稳定：不保证相等元素的原始相对顺序。
在现代软件开发中，虽然我们很少需要从头实现一个排序算法，但深入理解快速排序的原理、性能瓶颈和优化技巧，对于培养算法思维、解决更复杂的问题至关重要。它不仅是一个排序工具，更是一个蕴含着深刻设计哲学的经典范例。那些内置于我们日常使用的编程语言中的高级排序算法，很多都是站在快速排序这个巨人的肩膀上发展而来的。