地图
- 引子
- 代码地址
- 快速排序
- 核心代码
- 优劣
- 完整代码
- 演示
- 课后习题
引子
搭嘎好！本人最近看的《啊哈算法》这本书写的确实不错，生动形象，在保持算法讲解准确性的同时又不失趣味性。
但对我来说，稍显遗憾的是，书籍代码是c语言，而不是本人常用的Java。
那就弥补遗憾，说干就干，把这本书的示例语言用java给翻译一遍！！！
于是就有了本篇博客，这是第三篇博客，主要讲解快速排序。
来不及买纸质书但又想尽快感受算法魅力的童鞋也甭担心，电子版的下载链接已经放到下方了，可尽情下载。
链接：https://pan.baidu.com/s/1imxiElcCorw2F-HJEnB-PA?pwd=jmgs
提取码：jmgs
代码地址
本文代码已开源：
git clone https://gitee.com/guqueyue/my-blog-demo.git
请切换到gitee分支，
然后查看aHaAlgorithm模块下的src/main/java/com/guqueyue/aHaAlgorithm/chapter_1_Sort即可！
快速排序
快速排序，名字听起来就很快！
那么，这么快的排序是怎么实现的呢？我们这里以升序为例（降序的话找数的逻辑相反），把它拆解成以下几步：
-
选定一个基准值，这里我们一般选取第一个数为基准值
-
设定双指针，也就是书里面说的哨兵。
2.1 一个哨兵从
右往左走找比 基准值小(大) 的数，一个哨兵从左往右找比 基准值大(小) 的数，找到了就交换两个数。2.2 等到两个哨兵相遇就交换基准值和哨兵
这样数组的左边都是比 基准值小(大) 的数，右边都是比 基准值大(小) 的数。
-
以
左边界和基准值位置-1为一个数组，右边界和基准值位置+1为一个数组，再进行如上操作。
一直到左右边界相遇，则排序完成。
当然，这里面采用了递归的编程技巧，实现了分而治之的编程思想，才能达到我们想要的目的。
关于这个，我当初写的关于《算法图解》第三章<递归>、第四章<快速排序>里面也有相应的介绍：
肝了几万字，送给看了《算法图解》却是主攻Java的你和我（上篇）
相比于《算法图解》那本书，这本书讲快速排序明显要更加清晰直观。
下面是快速排序整体的流程图：
还没懂？列一个快速排序第一次交换的动图，是不是清晰很多了呢？
如果还是不是很明白，就去看书吧，里面有详细的图文步骤，我这里就不多加赘述啦。
核心代码
话已经说了很多了，直接上代码：
/**
* @Description 快速排序
* @Param [arr: 数组, left: 左边界, right: 右边界]
* @return void
**/
private static void quickSort(int[] arr, int left, int right) {
if (left > right) { // 左边不能大于右边
return;
}
int temp = arr[left]; // 基准值
int i = left, j = right;
while (i < j) {
// 找到比基准值更小的数，右边先找(为啥一定要右边先找？ - 1 3 2) 防止基准值是最小的数，左边先走，就会把基准值交换掉
while (arr[j] >= temp && i < j) {
j--;
}
// 找到比基准值更大的数,这边必须设置等于temp，不然左边的数不会走
while (arr[i] <= temp && i < j) {
i++;
}
// 如果没有相遇，则： i == j 时，没必要交换
if (i < j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
// 基准值归位
arr[left] = arr[j];
arr[j] = temp;
// 这里 i,j 是相等的
quickSort(arr, left, j-1); // 左半边继续排序
quickSort(arr, j+1, right); // 右半边继续排序
}
优劣
- 空间复杂度为
O(N)，属于 原地排序算法 了，即不占用额外的空间。 - 平均时间复杂度为
O(NlogN), 但是有些情况下时间复杂度最高可达O(N^2)，不过问题不大，最坏的情况也就和冒泡排序一样不是？
上面说到快速排序有最坏的情况时间复杂度为O(N^2)，你能想到是哪种情况吗？
想不到的话也没关系，下文有提示。
完整代码
诺：
package com.guqueyue.aHaAlgorithm.chapter_1_Sort;
import java.util.Arrays;
import java.util.Scanner;
/**
* @Author: guqueyue
* @Description: 快速排序
* @Date: 2024/1/10
**/
public class QuickSort {
public static void main(String[] args) {
// 获取整数数组
int[] arr = getArr();
System.out.println("输入的数组为：" + Arrays.toString(arr));
// 快速排序
quickSort(arr, 0, arr.length - 1);
System.out.println("排序后的数组为：" + Arrays.toString(arr));
}
/**
* @Description 快速排序
* @Param [arr: 数组, left: 左边界, right: 右边界]
* @return void
**/
private static void quickSort(int[] arr, int left, int right) {
if (left > right) { // 左边不能大于右边
return;
}
int temp = arr[left]; // 基准值
int i = left, j = right;
while (i < j) {
// 找到比基准值更小的数，右边先找(为啥一定要右边先找？ - 1 3 2) 防止基准值是最小的数，左边先走，就会把基准值交换掉
while (arr[j] >= temp && i < j) {
j--;
}
// 找到比基准值更大的数,这边必须设置等于temp，不然左边的数不会走
while (arr[i] <= temp && i < j) {
i++;
}
// 如果没有相遇，则： i == j 时，没必要交换
if (i < j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
// 基准值归位
arr[left] = arr[j];
arr[j] = temp;
// 这里 i,j 是相等的
quickSort(arr, left, j-1); // 左半边继续排序
quickSort(arr, j+1, right); // 右半边继续排序
}
/**
* @Description 获取整数数组
* @Param []
* @return int[]
**/
private static int[] getArr() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入数字个数：");
int n = scanner.nextInt();
int[] arr = new int[n];
System.out.printf("请输入%d个数, 中间用空格隔开，再回车：", n);
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
return arr;
}
}
演示
运行代码，控制台输入可得：
课后习题
在前两期博客中：
Java玩转《啊哈算法》排序之桶排序
Java玩转《啊哈算法》排序之冒泡排序
我都给出了力扣上面的同一道题，作为课后习题：
912. 排序数组
但是比较尴尬的是，用桶排序做这道题目，占用内存太多了，仅击败 34.93% 使用Java的用户！
如果用冒泡排序，那就更尴尬了，直接超时，通过都通过不了：
但是如果你学会了本文中的快速排序，能不能做到，又快又稳(占用内存少) 呢？
噔噔蹬蹬：
很遗憾，翻车了，又超时了，我们翻开超时的测试用例可以发现，有非常多的重复元素：
这也正印证了上文所说的，快速排序的执行速率不稳定，最差的时候跟冒泡排序是一样的。
虽然桶排序算法跟贪心算法一样因为思路都比较简单，所以容易被人轻视。
俗话说，真心（简单）往往留不住，唯有套路（复杂）得人心。
但是桶排序在这道题上面是当之无愧的老大哥！！！
看来没有最牛逼的算法，只有最合适的算法。
当然，快速排序针对多重复元素进行 三路快排 的话， 虽然速率还是比不上桶排序，但是也能通过这道题。
不过这个超纲了，不在本篇博客的讨论范围内了，感兴趣的同学可以去看一下这位朋友的题解：
快速排序优化（针对多重复元素情况）
