漫画：什么是快速排序？（完整版）

—————  第二天  —————

————————————

同冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换位置来达到排序的目的。

不同的是，冒泡排序在每一轮只把一个元素冒泡到数列的一端，而快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分。

这种思路就叫做分治法。

每次把数列分成两部分，究竟有什么好处呢？

假如给定8个元素的数列，一般情况下冒泡排序需要比较8轮，每轮把一个元素移动到数列一端，时间复杂度是O（n^2）。

而快速排序的流程是什么样子呢？

如图所示，在分治法的思想下，原数列在每一轮被拆分成两部分，每一部分在下一轮又分别被拆分成两部分，直到不可再分为止。

这样一共需要多少轮呢？平均情况下需要logn轮，因此快速排序算法的平均时间复杂度是 O（nlogn）。

基准元素的选择

基准元素，英文pivot，用于在分治过程中以此为中心，把其他元素移动到基准元素的左右两边。

那么基准元素如何选择呢？

最简单的方式是选择数列的第一个元素：

这种选择在绝大多数情况是没有问题的。但是，假如有一个原本逆序的数列，期望排序成顺序数列，那么会出现什么情况呢？

..........

我们该怎么避免这种情况发生呢？

其实很简单，我们可以不选择数列的第一个元素，而是随机选择一个元素作为基准元素。

这样一来，即使在数列完全逆序的情况下，也可以有效地将数列分成两部分。

当然，即使是随机选择基准元素，每一次也有极小的几率选到数列的最大值或最小值，同样会影响到分治的效果。

所以，快速排序的平均时间复杂度是 O（nlogn），最坏情况下的时间复杂度是 O（n^2）。

元素的移动

选定了基准元素以后，我们要做的就是把其他元素当中小于基准元素的都移动到基准元素一边，大于基准元素的都移动到基准元素另一边。

具体如何实现呢？有两种方法：

1.挖坑法

2.指针交换法

何谓挖坑法？我们来看一看详细过程。

给定原始数列如下，要求从小到大排序：

首先，我们选定基准元素Pivot，并记住这个位置index，这个位置相当于一个“坑”。并且设置两个指针left和right，指向数列的最左和最右两个元素：

接下来，从right指针开始，把指针所指向的元素和基准元素做比较。如果比pivot大，则right指针向左移动；如果比pivot小，则把right所指向的元素填入坑中。

在当前数列中，1<4，所以把1填入基准元素所在位置，也就是坑的位置。这时候，元素1本来所在的位置成为了新的坑。同时，left向右移动一位。

此时，left左边绿色的区域代表着小于基准元素的区域。

接下来，我们切换到left指针进行比较。如果left指向的元素小于pivot，则left指针向右移动；如果元素大于pivot，则把left指向的元素填入坑中。

在当前数列中，7>4，所以把7填入index的位置。这时候元素7本来的位置成为了新的坑。同时，right向左移动一位。

此时，right右边橙色的区域代表着大于基准元素的区域。

下面按照刚才的思路继续排序：

8>4，元素位置不变，right左移

2<4，用2来填坑，left右移，切换到left。

6>4，用6来填坑，right左移，切换到right。

3<4，用3来填坑，left右移，切换到left。

5>4，用5来填坑，right右移。这时候left和right重合在了同一位置。

这时候，把之前的pivot元素，也就是4放到index的位置。此时数列左边的元素都小于4，数列右边的元素都大于4，这一轮交换终告结束。

public class QuickSort {

1. public static void quickSort(int[] arr, int startIndex, int endIndex) {
2.    // 递归结束条件：startIndex大等于endIndex的时候
3.    if (startIndex >= endIndex) {
4.        return;
5.    }
6.    // 得到基准元素位置
7.    int pivotIndex = partition(arr, startIndex, endIndex);
8.    // 用分治法递归数列的两部分
9.    quickSort(arr, startIndex, pivotIndex - 1);
10.    quickSort(arr, pivotIndex + 1, endIndex);
11. }
12. 

14. private static int partition(int[] arr, int startIndex, int endIndex) {
15.    // 取第一个位置的元素作为基准元素
16.    int pivot = arr[startIndex];
17.    int left = startIndex;
18.    int right = endIndex;
19.    // 坑的位置，初始等于pivot的位置
20.    int index = startIndex;
22.    //大循环在左右指针重合或者交错时结束
23.    while ( right >= left  ){
24.        //right指针从右向左进行比较
25.        while ( right >= left ) {
26.            if (arr[right] < pivot) {
27.                arr[left] = arr[right];
28.                index = right;
29.                left++;
30.                break;
31.            }
32.            right--;
33.        }
34.        //left指针从左向右进行比较
35.        while ( right >= left ) {
36.            if (arr[left] > pivot) {
37.                arr[right] = arr[left];
38.                index = left;
39.                right--;
40.                break;
41.            }
42.            left++;
43.        }
44.    }
45.    arr[index] = pivot;
46.    return index;
47. }
48. 

50. public static void main(String[] args) {
51.    int[] arr = new int[] {4,7,6,5,3,2,8,1};
52.    quickSort(arr, 0, arr.length-1);
53.    System.out.println(Arrays.toString(arr));
54. }

}

代码中，quickSort方法通过递归的方式，实现了分而治之的思想。

partition方法则实现元素的移动，让数列中的元素依据自身大小，分别移动到基准元素的左右两边。在这里，我们使用移动方式是挖坑法。

指针交换法

何谓指针交换法？我们来看一看详细过程。

给定原始数列如下，要求从小到大排序：

开局和挖坑法相似，我们首先选定基准元素Pivot，并且设置两个指针left和right，指向数列的最左和最右两个元素：

接下来是第一次循环，从right指针开始，把指针所指向的元素和基准元素做比较。如果大于等于pivot，则指针向左移动；如果小于pivot，则right指针停止移动，切换到left指针。

在当前数列中，1<4，所以right直接停止移动，换到left指针，进行下一步行动。

轮到left指针行动，把指针所指向的元素和基准元素做比较。如果小于等于pivot，则指针向右移动；如果大于pivot，则left指针停止移动。

由于left一开始指向的是基准元素，判断肯定相等，所以left右移一位。

由于7 > 4，left指针在元素7的位置停下。这时候，我们让left和right指向的元素进行交换。

接下来，我们进入第二次循环，重新切换到right向左移动。right先移动到8，8>4，继续左移。由于2<4，停止在2的位置。

切换到left，6>4，停止在6的位置。

元素6和2交换。

进入第三次循环，right移动到元素3停止，left移动到元素5停止。

元素5和3交换。

进入第四次循环，right移动到元素3停止，这时候请注意，left和right指针已经重合在了一起。

当left和right指针重合之时，我们让pivot元素和left与right重合点的元素进行交换。此时数列左边的元素都小于4，数列右边的元素都大于4，这一轮交换终告结束。

public class QuickSort {

1. public static void quickSort(int[] arr, int startIndex, int endIndex) {
2.    // 递归结束条件：startIndex大等于endIndex的时候
3.    if (startIndex >= endIndex) {
4.        return;
5.    }
6.    // 得到基准元素位置
7.    int pivotIndex = partition(arr, startIndex, endIndex);
8.    // 根据基准元素，分成两部分递归排序
9.    quickSort(arr, startIndex, pivotIndex - 1);
10.    quickSort(arr, pivotIndex + 1, endIndex);
11. }
12. 

14. private static int partition(int[] arr, int startIndex, int endIndex) {
15.    // 取第一个位置的元素作为基准元素
16.    int pivot = arr[startIndex];
17.    int left = startIndex;
18.    int right = endIndex;
20.    while( left != right) {
21.        //控制right指针比较并左移
22.        while(left<right && arr[right] > pivot){
23.            right--;
24.        }
25.        //控制right指针比较并右移
26.        while( left<right && arr[left] <= pivot) {
27.            left++;
28.        }
29.        //交换left和right指向的元素
30.        if(left<right) {
31.            int p = arr[left];
32.            arr[left] = arr[right];
33.            arr[right] = p;
34.        }
35.    }
37.    //pivot和指针重合点交换
38.    int p = arr[left];
39.    arr[left] = arr[startIndex];
40.    arr[startIndex] = p;
42.    return left;
43. }
44. 

46. public static void main(String[] args) {
47.    int[] arr = new int[] {4,7,6,5,3,2,8,1};
48.    quickSort(arr, 0, arr.length-1);
49.    System.out.println(Arrays.toString(arr));
50. }

}

和挖坑法相比，指针交换法在partition方法中进行的元素交换次数更少。

非递归实现

为什么这样说呢？

因为我们代码中一层一层的方法调用，本身就是一个函数栈。每次进入一个新方法，就相当于入栈；每次有方法返回，就相当于出栈。

所以，我们可以把原本的递归实现转化成一个栈的实现，在栈当中存储每一次方法调用的参数：

下面我们来看一下代码：

public class QuickSortWithStack {

1. public static void quickSort(int[] arr, int startIndex, int endIndex) {
2.    // 用一个集合栈来代替递归的函数栈
3.    Stack<Map<String, Integer>> quickSortStack = new Stack<Map<String, Integer>>();
4.    // 整个数列的起止下标，以哈希的形式入栈
5.    Map rootParam = new HashMap();
6.    rootParam.put("startIndex", startIndex);
7.    rootParam.put("endIndex", endIndex);
8.    quickSortStack.push(rootParam);
10.    // 循环结束条件：栈为空时结束
11.    while (!quickSortStack.isEmpty()) {
12.        // 栈顶元素出栈，得到起止下标
13.        Map<String, Integer> param = quickSortStack.pop();
14.        // 得到基准元素位置
15.        int pivotIndex = partition(arr, param.get("startIndex"), param.get("endIndex"));
16.        // 根据基准元素分成两部分, 把每一部分的起止下标入栈
17.        if(param.get("startIndex") <  pivotIndex -1){
18.            Map<String, Integer> leftParam = new HashMap<String, Integer>();
19.            leftParam.put("startIndex",  param.get("startIndex"));
20.            leftParam.put("endIndex", pivotIndex -1);
21.            quickSortStack.push(leftParam);
22.        }
23.        if(pivotIndex + 1 < param.get("endIndex")){
24.            Map<String, Integer> rightParam = new HashMap<String, Integer>();
25.            rightParam.put("startIndex", pivotIndex + 1);
26.            rightParam.put("endIndex", param.get("endIndex"));
27.            quickSortStack.push(rightParam);
28.        }
29.    }
30. }
32. private static int partition(int[] arr, int startIndex, int endIndex) {
33.    // 取第一个位置的元素作为基准元素
34.    int pivot = arr[startIndex];
35.    int left = startIndex;
36.    int right = endIndex;
38.    while( left != right) {
39.        //控制right指针比较并左移
40.        while(left<right && arr[right] > pivot){
41.            right--;
42.        }
43.        //控制right指针比较并右移
44.        while( left<right && arr[left] <= pivot) {
45.            left++;
46.        }
47.        //交换left和right指向的元素
48.        if(left<right) {
49.            int p = arr[left];
50.            arr[left] = arr[right];
51.            arr[right] = p;
52.        }
53.    }
55.    //pivot和指针重合点交换
56.    int p = arr[left];
57.    arr[left] = arr[startIndex];
58.    arr[startIndex] = p;
60.    return left;
61. }
63. public static void main(String[] args) {
64.    int[] arr = new int[] {4,7,6,5,3,2,8,1};
65.    quickSort(arr, 0, arr.length-1);
66.    System.out.println(Arrays.toString(arr));
67. }

}

和刚才的递归实现相比，代码的变动仅仅在quickSort方法当中。该方法中引入了一个存储Map类型元素的栈，用于存储每一次交换时的起始下标和结束下标。

每一次循环，都会让栈顶元素出栈，进行排序，并且按照基准元素的位置分成左右两部分，左右两部分再分别入栈。当栈为空时，说明排序已经完毕，退出循环。

几点补充：

本漫画纯属娱乐，还请大家尽量珍惜当下的工作，切勿模仿小灰的行为哦。

—————END—————