快速排序
文章目录
1. 算法概述
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，称为 “基准”（pivot）
- 然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，相同的数可以到任一边，这个过程称为一趟快速排序，该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
2. 图解
分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。先从右往左找一个小于 6 的数，再从左往右找一个大于 6 的数，然后交换他们。这里可以用两个变量 i 和 j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵 i”和“哨兵 j”。刚开始的时候让哨兵 i 指向序列的最左边（即 i=0），指向数字 6。让哨兵 j 指向序列的最右边（即 j=9），指向数字 8。
首先哨兵 j 开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵 j 先出动，这一点非常重要（请自己想一想为什么）。哨兵 j 一步一步地向左挪动（即 j–），直到找到一个小于 6 的数停下来。接下来哨兵 i 再一步一步向右挪动（即 i++），直到找到一个数大于 6 的数停下来。最后哨兵 j 停在了数字 5 面前，哨兵 i 停在了数字 7 面前。
进行第一次交换，交换哨兵 i 和哨兵 j 所指向的元素的值。交换之后的序列如下。6 1 2 5 9 3 4 7 10 8
接下来开始哨兵 j 继续向左挪动（再友情提醒，每次必须是哨兵 j 先出发）。他发现了 4（比基准数 6 要小，满足要求）之后停了下来。哨兵 i 也继续向右挪动的，他发现了 9（比基准数 6 要大，满足要求）之后停了下来。
进行第二次交换，交换之后的序列如下。6 1 2 5 4 3 9 7 10 8
交换结束，“探测”继续。哨兵 j 继续向左挪动，他发现了 3（比基准数 6 要小，满足要求）之后又停了下来。哨兵 i 继续向右移动，糟啦！此时哨兵 i 和哨兵 j 相遇了，哨兵 i 和哨兵 j 都走到 3 面前。
说明此时“探测”结束。我们将基准数 6 和 3 进行交换。
交换之后的序列如下。3 1 2 5 4 6 9 7 10 8
到此第一轮“探测”真正结束。此时以基准数 6 为分界点，6 左边的数都小于等于 6，6 右边的数都大于等于 6。回顾一下刚才的过程，其实哨兵 j 的使命就是要找小于基准数的数，而哨兵 i 的使命就是要找大于基准数的数，直到 i 和 j 碰头为止。
OK，解释完毕。现在基准数 6 已经归位，它正好处在序列的第 6 位。此时我们已经将原来的序列，以 6 为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“ 9 7 10 8 ”。接下来还需要分别处理这两个序列。因为 6 左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理 6 左边和右边的序列即可。现在先来处理 6 左边的序列现吧。
左边的序列是“3 1 2 5 4”。请将这个序列以 3 为基准数进行调整，使得 3 左边的数都小于等于 3，3 右边的数都大于等于 3。好了开始动笔吧。
如果你模拟的没有错，调整完毕之后的序列的顺序应该是。2 1 3 5 4
OK，现在 3 已经归位。接下来需要处理 3 左边的序列“ 2 1 ”和右边的序列“5 4”。对序列“ 2 1 ”以 2 为基准数进行调整，处理完毕之后的序列为“1 2”，到此 2 已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“ 2 1 ”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下。
1 2 3 4 5 6 9 7 10 8
对于序列“9 7 10 8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会得到这样的序列，如下。
1 2 3 4 5 6 7 8 9 10
到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了，这个快排中的挖坑填位法。下面上个霸气的图来描述下整个算法的处理过程。
快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是 O(n2)，它的平均时间复杂度为 O(nlogn)。其实快速排序是基于一种叫做“二分”的思想。
3. 代码实现（挖坑填位）
数据交换代码
private void swap(int[] arr, int low, int high) {
int temp = arr[low];
arr[low] = arr[high];
arr[high] = temp;
}
代码实现如下：
public void sort1(int[] arr, int low, int high) {
int l = low, h = high;
//设置基准，同时空出索引位置low
int pivot = arr[low];
while (l < h) {
//从右往左搜索，不能<=l，找<pivot
while (l < h && arr[h] >= pivot) {
h--;
}
//从左往右搜索，不能>=h，找>pivot
while (l < h && arr[l] < pivot) {
l++;
}
//如果l==h，则表明两者相遇，都没有找到 >povit 或者 < povit 的数据，则将相遇位置的元素与基准元素交换
if (l == h) {
arr[low] = arr[h];
arr[h] = pivot;
//这个break；是多余的，应为while条件是 l < h，但是应该知道，这个时候是需要退出循环的
//break;
} else {
//否则，则表明两者都找到 >povit 或者 < povit 的数据，将两者交换。
swap(arr, l, h);
}
}
//此时，应该 l==h，因为上述循环，已经将两者相遇
//判断相遇位置索引是否 > 基准元素索引，如果是则表明，还没有排序完成，递归排序小数值集合
if (l - 1 > low) {
sort1(arr, low, l - 1);
}
//判断相遇位置索引是否 < 基准元素索引，如果是则表明，还没有排序完成，递归排序小数值集合
if (l + 1 < high) {
sort1(arr, l + 1, high);
}
}
4. 算法优化
4.1 减少因交换元素而创建临时变量
因为交换操作需要进行3次赋值操作，而替换操作只需要进行1次赋值操作。
public static void sort2(int[] arr, int low, int high) {
int l = low, h = high;
//设置基准，同时空出索引位置low
int pivot = arr[low];
while (l < h) {
//从右往左搜索，不能<=l，找<pivot
while (l < h && arr[h] >= pivot) {
h--;
}
//走到这里来，证明两种情况，一是：碰见符合条件的元素(<pivot)，二是：没有碰见符合条件元素，h-- 后 == l
//如果情况一：则将小元素替换之l位置（第一次默认是索引0 pivot所在的位置）
//因为索引0的位置已经存储在变量pivot中，不会丢失。而操作之后，h位置空出
if(h != l){
//如果
arr[l] = arr[h];
}
//从左往右搜索，不能>=h，找>pivot
while (l < h && arr[l] < pivot) {
l++;
}
//走到这里来，证明两种情况，一是：碰见符合条件的元素(>pivot)，二是：没有碰见符合条件元素，l++ 后 == h
//如果情况一：则将大元素替换之h位置，新l空出位置
if(h != l){
arr[h] = arr[l];
}
}
//将基准元素，放进空位
arr[l] = pivot;
//此时，应该 l==h，因为上述循环，已经将两者相遇
//判断相遇位置索引是否 > 基准元素索引，如果是则表明，还没有排序完成，递归排序小数值集合
if (l - 1 > low) {
sort2(arr, low, l - 1);
}
//判断相遇位置索引是否 < 基准元素索引，如果是则表明，还没有排序完成，递归排序小数值集合
if (l + 1 < high) {
sort2(arr, l + 1, high);
}
}
4.2 优化枢轴（基准元素）的选取方式
枢轴常见的选取方式有：固定位置选取、随机位置选取、三值取中法。
固定位置选取：选取当前序列的第一个元素或者最后一个元素作为枢轴，上述案例就是采用该方法。该方法不是一个好的选取方案，因为当整个序列有序时，每次分区操作只会将待排序序列减1，此时为最坏情况，算法复杂度沦为O(n^2)。然而，在待排序的序列中局部有序是相当常见的，所以固定位置选取枢轴不是一种好的选择。
随机位置选取：随机选取当前待排序序列的任意记录作为枢轴。由于采取随机，所以时间性能要强于固定位置选取。
三值取中法： 对待排序序列中low、mid、high三个位置上数据进行排序，取他们中间的那个数据作为枢轴，并用0下标元素存储枢轴，比如:
9 1 7 5 2 8 6 3 4
↑ ↑ ↑
low mid high
前 中 后
通过三值取中法处理后的数组因为
4 1 7 5 2 8 6 3 9
↑
piovt
三值取中本质上就是随机位置选取，但是由于随机位置选取过程中需要用到随机种子来产生随机数，而三值取中不需要，所以三值取中要优于随机位置选取。
三值取中法代码
/**
* 三值取中法
* @param arr
* @param low
* @param high
* @return
*/
private int getMiddle4Three(int[] arr, int low, int high) {
//取中
int mid = (low + high) >>> 1;
//如果中间比尾大，则交换位置，小数放在中间位置，无论交换：arr[mind] <= arr[high]
if (arr[mid] > arr[high]) {
swap(arr, mid, high);
}
//如果中间比头大，则交换位置，将中间放在第一位，无论交换：arr[low] >= arr[mind]
if (arr[mid] > arr[low]) {
swap(arr, mid, low);
}
//如果头比尾大，则交换位置，将尾放在第一位，无论交换：arr[low] <= arr[high]
if (arr[low] > arr[high]) {
swap(arr, low, high);
}
//因：arr[low] >= arr[mind]
//又因：arr[mind] <= arr[high] 且 arr[low] <= arr[high]
//则：arr[low] 尾 low mid high 中间值
return arr[low];
}
优化后的快排代码
public void sort3(int[] arr, int low, int high) {
int l = low, h = high;
//三值取中, 0下标元素存储枢轴。返回pivot
int pivot = getMiddle4Three(arr, l, h);
while (l < h) {
//右->左，查找 < pivot,否则一直循环
while (l < h && arr[h] >= pivot) {
h--;
}
//两者不等，则表示还没有篇碰头,交换元素
if (h != l) {
arr[l] = arr[h];
}
//左->右，查找 >pivot,否则一直循环
while (l < h && arr[l] < pivot) {
l++;
}
//两者不等，则表示还没有篇碰头,交换元素
if (h != l) {
arr[h] = arr[l];
}
}
//将基准元素，放进空位
arr[l] = pivot;
//判断碰头后，基准元素的索引 是否与 碰头索引一直，不一致则表示还没有结束排序
if (l - 1 > low) {
sort2(arr, low, l - 1);
}
if (l + 1 > high) {
sort2(arr, low, l + 1);
}
}
4.3 优化小数组时的排序方案
当局部排序数组长度较小时，采用插入排序，而非快速排序，因为长度分割到够小后，继续分割的效率要低于直接插入排序。
扫一扫
4044
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
