Java实现快速排序算法
用「整理书架」理解快速排序原理
想象你有一堆杂乱的书需要按大小排序，快速排序的步骤可以类比为：
1. 选一本“基准书”（比如最右侧的书）
2. 把书分成三堆：
- 左边：比基准小的书
- 中间：基准书
- 右边：比基准大的书
3. 递归整理左右两堆：对左边和右边的书堆重复上述过程
---
一、算法原理（分治思想）
| 步骤 | 操作描述 | 时间复杂度 |
|------|-------------------------|------------|
| 1 | 选择基准元素（Pivot） | O(1) |
| 2 | 分区：小左大右 | O(n) |
| 3 | 递归处理左右子数组 | O(log n) |
总时间复杂度：平均 **O(n log n)，最差 O(n²)（可通过优化避免）
---
二、Java代码实现（带详细注释）
```java
public class QuickSort {
public static void main(String[] args) {
int[] arr = {6, 3, 8, 2, 9, 1};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 3, 6, 8, 9]
}
// 快速排序主方法
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high); // 分区并获取基准位置
quickSort(arr, low, pivotIndex - 1); // 排左边
quickSort(arr, pivotIndex + 1, high); // 排右边
}
}
// 分区操作（核心）
private static int partition(int[] arr, int low, int high) {
int pivot = arr[high]; // 选最后一个元素为基准
int i = low - 1; // 小元素区的指针
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) { // 当前元素比基准小
i++;
swap(arr, i, j); // 把小的换到左边
}
}
swap(arr, i + 1, high); // 基准放到正确位置
return i + 1;
}
// 交换数组元素
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
```
---
三、图解示例（以数组 [6,3,8,2,9,1] 为例）
第一次分区过程：
基准：1（最后一个元素）
结果：左区空（没有比1小的），1放最前 → [1,3,8,2,9,6]
递归处理右子数组 [3,8,2,9,6]：
基准：6 → 分区后 → [3,2,6,8,9]
---
四、应用场景
| 场景 | 说明 |
|-------------------|----------------------------------------------------------------------|
| 内存排序 | Java的 `Arrays.sort()` 对基本类型使用快速排序优化版（双轴快排） |
| 大数据处理 | 适合处理内存中的大规模数据排序（如日志分析） |
| 需要不稳定排序时 | 快速排序是不稳定排序（相同元素可能改变顺序） |
**对比其他排序算法**：
- 归并排序：稳定但需要额外空间
- 堆排序：适合动态数据，但常数项较大
- 快速排序：综合速度最快（优化后）
---
五、常见优化技巧
1. 基准选择优化
```java
// 三数取中法：避免选到极值
int mid = low + (high - low)/2;
if (arr[low] > arr[high]) swap(arr, low, high);
if (arr[mid] > arr[high]) swap(arr, mid, high);
if (arr[low] < arr[mid]) swap(arr, low, mid);
```
2. 小数组切换插入排序
```java
if (high - low < 10) {
insertionSort(arr, low, high);
return;
}
```
3. 尾递归优化
```java
while (low < high) {
int pivot = partition(arr, low, high);
quickSort(arr, low, pivot-1);
low = pivot + 1; // 减少递归深度
}
```
---
通过这种分而治之的策略，快速排序成为了最常用的排序算法之一。理解其核心思想后，可以轻松应对各种变形题目（如寻找第K大的元素）。