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

相关推荐
代码的余温36 分钟前
5种高效解决Maven依赖冲突的方法
java·maven
慕y27439 分钟前
Java学习第十六部分——JUnit框架
java·开发语言·学习
paishishaba1 小时前
Maven
java·maven
张人玉1 小时前
C# 常量与变量
java·算法·c#
Java技术小馆1 小时前
GitDiagram如何让你的GitHub项目可视化
java·后端·面试
学不动CV了2 小时前
数据结构---链表结构体、指针深入理解(三)
c语言·arm开发·数据结构·stm32·单片机·链表
Codebee2 小时前
“自举开发“范式:OneCode如何用低代码重构自身工具链
java·人工智能·架构
weixin_446122462 小时前
LinkedList剖析
算法
程序无bug2 小时前
手写Spring框架
java·后端
程序无bug2 小时前
Spring 面向切面编程AOP 详细讲解
java·前端