Java实现快速排序算法

用「整理书架」理解快速排序原理

想象你有一堆杂乱的书需要按大小排序,快速排序的步骤可以类比为:

  1. 选一本"基准书"(比如最右侧的书)

  2. 把书分成三堆:

  • 左边:比基准小的书

  • 中间:基准书

  • 右边:比基准大的书

  1. 递归整理左右两堆:对左边和右边的书堆重复上述过程

一、算法原理(分治思想)

| 步骤 | 操作描述 | 时间复杂度 |

|------|-------------------------|------------|

| 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 = arrhigh; // 选最后一个元素为基准

int i = low - 1; // 小元素区的指针

for (int j = low; j < high; j++) {

if (arrj <= 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 = arri;

arri = arrj;

arrj = 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 (arrlow > arrhigh) swap(arr, low, high);

if (arrmid > arrhigh) swap(arr, mid, high);

if (arrlow < arrmid) swap(arr, low, mid);

```

  1. 小数组切换插入排序

```java

if (high - low < 10) {

insertionSort(arr, low, high);

return;

}

```

  1. 尾递归优化

```java

while (low < high) {

int pivot = partition(arr, low, high);

quickSort(arr, low, pivot-1);

low = pivot + 1; // 减少递归深度

}

```


通过这种分而治之的策略,快速排序成为了最常用的排序算法之一。理解其核心思想后,可以轻松应对各种变形题目(如寻找第K大的元素)。

相关推荐
特立独行的猫A1 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
一起_java1 小时前
技术文章-基于Dify-Agent的智能问答系统设计与实现
java·spring boot·后端·agent·dify
Flynn Liang3 小时前
I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS
java·spring boot·性能优化·高并发·系统设计·虚拟线程·io密集型
吃我一窝jio4 小时前
Python与Go线程模型深度对比
java·开发语言·python
这个昵称不容易4 小时前
SpringBoot 购物推荐网站的设计与实现:120 个 Java 文件、147 个接口、13 张表,附真实运行截图
java·springboot·毕设
文丑颜不良啊4 小时前
LeetCode3041~3060题目解析
java·leetcode
罗西的思考4 小时前
【轻量化复现大模型 / KIMI K3】MTP / EAGLE‑3 模块交互式演示
人工智能·深度学习·算法
文丑颜不良啊5 小时前
LeetCode3101~3120题目解析
java·leetcode
Resean02236 小时前
SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)
java·spring·springmvc
靠沿6 小时前
MySQL数据库进阶——存储过程和触发器
java·数据库·mysql