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

相关推荐
缺点内向3 小时前
Java:创建、读取或更新 Excel 文档
java·excel
我搞slam3 小时前
快乐数--leetcode
算法·leetcode·哈希算法
带刺的坐椅3 小时前
Solon v3.4.7, v3.5.6, v3.6.1 发布(国产优秀应用开发框架)
java·spring·solon
WWZZ20254 小时前
快速上手大模型:机器学习3(多元线性回归及梯度、向量化、正规方程)
人工智能·算法·机器学习·机器人·slam·具身感知
四谎真好看5 小时前
Java 黑马程序员学习笔记(进阶篇18)
java·笔记·学习·学习笔记
桦说编程5 小时前
深入解析CompletableFuture源码实现(2)———双源输入
java·后端·源码
东方佑5 小时前
从字符串中提取重复子串的Python算法解析
windows·python·算法
java_t_t5 小时前
ZIP工具类
java·zip
西阳未落5 小时前
LeetCode——二分(进阶)
算法·leetcode·职场和发展
lang201509285 小时前
Spring Boot优雅关闭全解析
java·spring boot·后端