排序算法——随机快速排序

引言

随机快排是一个非常有意思的排序排序算法，它的算法思想用到了如递归、荷兰国旗问题等诸多元素，还意外的引入了随机性的概念。

以下将逐步总结三个版本的快速排序，由浅入深总结快速排序的经典实现过程。

荷兰国旗问题参考：《荷兰国旗问题》

一、快速排序1.0

在荷兰国旗问题中，我们通过简单的逻辑可以将一个数组分为两个区域或三个区域，但往往需要在题目之初给定一个 target 作为目标数以此划分。

而在快速排序算法中，这个 target 选为排序范围上的最右边的数——arr[R]，我们以 R 上的数为 target 将R位置左侧先划分为两块区域小于等于区和大于区，最后再将 R 与大于区域的第一个数交换就可以完成整体的划分。

通过上面的这个主过程，我们通过递归，将左右两部分递归完成上面的过程，最终就可以实现整个数组的有序。

注意，在具体编码时，由于递归每次都需要选出一个数作为基准数，依此划分两块区域，在这个版本中，我们以 R 位置上的数为基准数，以此来划分，循环完毕后，我们只实现了R位置左侧的内容变为小于等于区和大于区，这时必须在循环外部额外单独处理一次基准数，做法就是将它与小于等于区的右边+1位置交换，并将小于等于区扩大一个位置即可。

    private static int partition(int[] arr, int L, int R) {if (L > R)return -1;if (L == R)return L;int lessEqual = L - 1;int cur = L;while (cur < R) {if (arr[cur] <= arr[R])SortUtil.swap(arr, ++lessEqual, cur);// 这里必须写在 if 外面自加，如果写在传参处自加，会导致大于时无法自加cur++;}SortUtil.swap(arr, ++lessEqual, R);return lessEqual;}

最后通过递归完成划分区域的步骤：

    public static void quickSort1(int[] arr) {// 注意不要写成 lenth == 0if (arr == null || arr.length < 2)return;process1(arr, 0, arr.length - 1);}private static void process1(int[] arr, int L, int R) {if (L >= R)return;int M = partition(arr, L, R);process1(arr, L, M - 1);process1(arr, M + 1, R);}

说明一下 M，它代表一个[L, R]范围上的中点位置，取自 partition 方法的返回值。partition 方法将 L R 范围上的数组划分成两个区域——小于等于区和大于区，M 即为上一次分区划分的基准数。

就1.0版本的快排而言，由于每次基准数都取自 R 位置上的数，那么思考这样一个问题，最理想的基准数和最差基准数分别是怎样的情况呢？

如果可以将 [L, R] 范围上的数充分等分，那么这就是最理想的基准数，如果范围上的数都偏向基准数一侧，那么就可能使算法花费更长的执行时间。

二、快速排序2.0

在1.0 中，我们选取基准数将[L, R]范围上的数划分为两部分，但是对于基准数重复的情况，它可能会造成在小于等于区不连续的情况，导致可能需要重复选择相同基准数的问题。

对于这个问题，通过荷兰国旗问题（三块分）的方法可以很好的优化。

    /** 快排2.0*/public static void quickSort2(int[] arr) {if (arr == null || arr.length < 2)return;process2(arr, 0, arr.length - 1);}/** 迭代处理*/private static void process2(int[] arr, int L, int R) {if (L >= R)return;int[] midRange = Code2_NetherlandsFlag.netherlandsFlag(arr, L, R, arr[R]);process2(arr, L, midRange[0] - 1);process2(arr, midRange[1] + 1, R);}/*** 荷兰国旗划分*/public static int[] netherlandsFlag(int[] arr, int L, int R, int target) {if (L > R)return new int[]{-1, -1};if (L == R)return new int[]{L, R};int less = L - 1;int more = R + 1;int curr = L;while (curr < more) {if (arr[curr] == target) {curr++;} else if (arr[curr] < target) {SortUtil.swap(arr, curr, less + 1);less++;curr++;} else {SortUtil.swap(arr, curr, more - 1);more--;}}// 等于区域的左边界和右边界 [less + 1, more - 1]return new int[]{less + 1, more - 1};}

三、快速排序 3.0 —— 随机快速排序

在1.0的版本中提到，当 R 位置选取的基准数可以比较好的中分数组元素，那么递归函数处理两侧的时间就会大致均分，从而可以达到 O(N * logN) 时间复杂度，而为了更好的达到这一点，在 2.0 基础之上，我们需要随机选取数组上的一个元素，将其视为基准数，然后其他的内容基本和 2.0 没有任何区别。

注意，在随机快排的递归进行前选取基准数的时候，我们依然选取 R 位置上的数，只不过我们会先随机一个位置，将其换到 R 位置上，在进行递归处理：

完整代码如下：

    /** 快排3.0*/public static void quickSort3(int[] arr) {if (arr == null || arr.length < 2)return;process3(arr, 0, arr.length - 1);}private static void process3(int[] arr, int L, int R) {if (L >= R)return;// 随机选取1个位置上的数换到 R 位置上SortUtil.swap(arr, L + (int) Math.random() * (R - L + 1), R);int[] midRange = Code2_NetherlandsFlag.netherlandsFlag(arr, L, R, arr[R]);process2(arr, L, midRange[0] - 1);process2(arr, midRange[1] + 1, R);}public static int[] netherlandsFlag(int[] arr, int L, int R, int target) {if (L > R)return new int[]{-1, -1};if (L == R)return new int[]{L, R};int less = L - 1;int more = R + 1;int curr = L;while (curr < more) {if (arr[curr] == target) {curr++;} else if (arr[curr] < target) {SortUtil.swap(arr, curr, less + 1);less++;curr++;} else {SortUtil.swap(arr, curr, more - 1);more--;}}// 等于区域的左边界和右边界 [less + 1, more - 1]return new int[]{less + 1, more - 1};}