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 = 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);

```

  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大的元素)。

相关推荐
飛_2 小时前
解决VSCode无法加载Json架构问题
java·服务器·前端
朝朝又沐沐4 小时前
算法竞赛阶段二-数据结构(36)数据结构双向链表模拟实现
开发语言·数据结构·c++·算法·链表
木棉软糖4 小时前
一个MySQL的数据表最多能够存多少的数据?
java
程序视点5 小时前
Java BigDecimal详解:小数精确计算、使用方法与常见问题解决方案
java·后端
愿你天黑有灯下雨有伞5 小时前
Spring Boot SSE实战:SseEmitter实现多客户端事件广播与心跳保活
java·spring boot·spring
薰衣草23335 小时前
一天两道力扣(6)
算法·leetcode
剪一朵云爱着5 小时前
力扣946. 验证栈序列
算法·
遇见尚硅谷5 小时前
C语言:*p++与p++有何区别
c语言·开发语言·笔记·学习·算法
Java初学者小白5 小时前
秋招Day20 - 微服务
java
天天开心(∩_∩)5 小时前
代码随想录算法训练营第三十二天
算法