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

相关推荐
ccccczy_9 分钟前
Java微服务容器化与 Kubernetes 编排实战:从 Docker 多阶段构建到云原生弹性扩展
java·docker·kubernetes·springboot·microservices·cloudnative·containerization
沉木渡香1 小时前
VSCode中Java开发环境配置的三个层级(Windows版)1-3
java·windows·vscode
程序员小白条1 小时前
度小满运维开发一面
java·运维·python·职场和发展·运维开发
小狗照亮每一天1 小时前
【菜狗学聚类】序列嵌入表示、UMAP降维——20250930
算法·分类·聚类
彩云回3 小时前
支持向量机(SVM)
算法·机器学习·支持向量机
Leo655356 小时前
JDK8 的排序、分组求和,转换为Map
java·开发语言
Asmalin8 小时前
【代码随想录day 29】 力扣 135.分发糖果
算法·leetcode·职场和发展
微笑尅乐8 小时前
多解法详解与边界处理——力扣7.整数反转
算法·leetcode·职场和发展
夏鹏今天学习了吗8 小时前
【LeetCode热题100(31/100)】K 个一组翻转链表
算法·leetcode·链表
薰衣草23338 小时前
力扣——位运算
python·算法·leetcode