1. 归并排序
1.1 归并排序的原理
以数组 [2, 1, 3, 6, 5, 2] 为例来讲解归并排序的思路。首先，将待排序数组均分为两个数组，并将这两个数组排序。结果即 [1, 2, 3] 和 [2, 5, 6]。接下来，将这两个数组合并，使其整体有序。思路是创建一个 buffer，从这两个数组的首元素开始对比，将较小的元素放入 buffer。倘若两个子数组中取到的元素相等，将左侧的元素放入 buffer。直至某个子数组下标越界，将另一个子数组中的剩余元素放入 buffer。以上工作完成后，再将 buffer 中排好序的元素拷贝回原数组。
接下来的描述中，黑体的元素即为下标所指的待处理元素。
左子数组 右子数组 buffer
[1, 2, 3] [2, 5, 6] []
[1, 2, 3] [2, 5, 6] [1]
[1, 2, 3] [2, 5, 6] [1, 2]
[1, 2, 3] [2, 5, 6] [1, 2, 2]
[1, 2, 3] [2, 5, 6] [1, 2, 2, 3]
[1, 2, 3] [2, 5, 6] [1, 2, 2, 3, 5, 6]
简而言之，归并排序整体就是一个简单递归，将左边排好序，右边也排好序，然后再使其整体有序。让其整体有序的过程中用了外排序方法（先将数据放在外部数组里，排序完成再拷回来）。
1.2 归并排序代码示例
1 public class MergeSort {
2
3 public static void mergeSort(int[] arr) {
4 if (arr == null || arr.length < 2) {
5 return;
6 }
7
8 process(arr, 0, arr.length - 1);
9 }
10
11 public static void process(int[] arr, int L, int R) {
12 if (L == R) {
13 return;
14 }
15
16 int mid = L + ((R - L) >> 1);
17 process(arr, L, mid);
18 process(arr, mid + 1, R);
19 merge(arr, L, mid, R);
20 }
21
22 public static void merge(int[] arr, int L, int M, int R) {
23 int[] help = new int[R - L + 1];
24 int i = 0;
25 int p1 = L;
26 int p2 = M + 1;
27
28 while (p1 <= M && p2 <= R) {
29 help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
30 }
31
32 while (p1 <= M) {
33 help[i++] = arr[p1++];
34 }
35
36 while (p2 <= R) {
37 help[i++] = arr[p2]++;
38 }
39
40 for (int i = 0; i < help.length; i++) {
41 arr[L + i] = help[i];
42 }
43
44 return;
45 }
46
47 }
1.3 归并排序的时间复杂度和额外空间复杂度
利用 master 公式来求解时间复杂度，a = 2， b = 2，d = 1。套用 master 公式，即可得到时间复杂度为 O(Nlog N)。
额外空间复杂度为 O(N)。
1.4 归并排序的实质
选择排序、插入排序、冒泡排序的时间复杂度均为 O(N2)。它们就差在浪费了很多比较行为。以冒泡排序为例，第一次比较 0～N-1 之间的元素，搞定一个数。第二次比较 1～N-1 之间的元素，搞定一个数。以此类推。但这些排序是相互独立的，丢弃了大量的数据。
归并排序之所以能把时间复杂度优化到 O(Nlog N)，是因为没有浪费比较行为。每次比较完成，都会将一个元素排好序。
1.5 归并排序的扩展——小和问题
1.5.1 小和问题概述
在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。以数组 [1, 3, 4, 2, 5] 为例，1 左边没有比 1 小的数。3 左边比 3 小的数是 1。4 左边比 4 小的数是 1、3。2 左边比 2 小的数是 1。5 左边比 5 小的数是 1、3、4、2。综上，小和为 1 + 1 + 3 + 1 + 1 + 3 + 4 + 2 = 16。
1.5.2 小和问题的思路转化
求小和的问题，可以转化为判断在某个元素的右侧，有几个元素比它大的问题。右侧有几个比它大的元素，该元素就被计算几次小和。因此，可以将求小和转化为类似归并排序的问题。但有两个问题需要明确：
-
- 排序的操作是不能去掉的。因为我们在归并过程中希望直接根据下标判断，右侧有几个元素比当前元素大。这样做的前提是有序。
- 当左侧子数组和右侧子数组当前需要判断的元素相等时，归并排序是将左侧子数组中的元素放入 buffer。求小和的操作则应将右侧子数组中的元素放入 buffer，否则怎么知道右侧有几个元素比当前元素大呢？
1.5.3 小和问题示例代码
1 public class Code02_SmallSum {
2
3 public static int smallSum(int[] arr) {
4 if (arr == null || arr.length < 2) {
5 return 0;
6 }
7 return mergeSort(arr, 0, arr.length - 1);
8 }
9
10 public static int mergeSort(int[] arr, int l, int r) {
11 if (l == r) {
12 return 0;
13 }
14 int mid = l + ((r - l) >> 1);
15 return mergeSort(arr, l, mid)
16 + mergeSort(arr, mid + 1, r)
17 + merge(arr, l, mid, r);
18 }
19
20 public static int merge(int[] arr, int l, int m, int r) {
21 int[] help = new int[r - l + 1];
22 int i = 0;
23 int p1 = l;
24 int p2 = m + 1;
25 int res = 0;
26 while (p1 <= m && p2 <= r) {
27 res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
28 help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
29 }
30 while (p1 <= m) {
31 help[i++] = arr[p1++];
32 }
33 while (p2 <= r) {
34 help[i++] = arr[p2++];
35 }
36 for (i = 0; i < help.length; i++) {
37 arr[l + i] = help[i];
38 }
39 return res;
40 }
41
42 // for test
43 public static int comparator(int[] arr) {
44 if (arr == null || arr.length < 2) {
45 return 0;
46 }
47 int res = 0;
48 for (int i = 1; i < arr.length; i++) {
49 for (int j = 0; j < i; j++) {
50 res += arr[j] < arr[i] ? arr[j] : 0;
51 }
52 }
53 return res;
54 }
55
56 // for test
57 public static int[] generateRandomArray(int maxSize, int maxValue) {
58 int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
59 for (int i = 0; i < arr.length; i++) {
60 arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
61 }
62 return arr;
63 }
64
65 // for test
66 public static int[] copyArray(int[] arr) {
67 if (arr == null) {
68 return null;
69 }
70 int[] res = new int[arr.length];
71 for (int i = 0; i < arr.length; i++) {
72 res[i] = arr[i];
73 }
74 return res;
75 }
76
77 // for test
78 public static boolean isEqual(int[] arr1, int[] arr2) {
79 if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
80 return false;
81 }
82 if (arr1 == null && arr2 == null) {
83 return true;
84 }
85 if (arr1.length != arr2.length) {
86 return false;
87 }
88 for (int i = 0; i < arr1.length; i++) {
89 if (arr1[i] != arr2[i]) {
90 return false;
91 }
92 }
93 return true;
94 }
95
96 // for test
97 public static void printArray(int[] arr) {
98 if (arr == null) {
99 return;
100 }
101 for (int i = 0; i < arr.length; i++) {
102 System.out.print(arr[i] + " ");
103 }
104 System.out.println();
105 }
106
107 // for test
108 public static void main(String[] args) {
109 int testTime = 500000;
110 int maxSize = 100;
111 int maxValue = 100;
112 boolean succeed = true;
113 for (int i = 0; i < testTime; i++) {
114 int[] arr1 = generateRandomArray(maxSize, maxValue);
115 int[] arr2 = copyArray(arr1);
116 if (smallSum(arr1) != comparator(arr2)) {
117 succeed = false;
118 printArray(arr1);
119 printArray(arr2);
120 break;
121 }
122 }
123 System.out.println(succeed ? "Nice!" : "Fucking fucked!");
124 }
125
126 }
1.6 归并排序的扩展——逆序对问题
1.6.1 逆序对问题概述
在一个数组中，左边的数如果比右边的数大，则这两个数构成一个逆序对。给定数组，请计算逆序对数量。
1.6.2 逆序对问题思路转化
逆序对问题可以转化为求某个元素右侧有几个元素比它小的问题。
1.6.3 逆序对问题代码示例
2 荷兰国旗问题
2.1 问题一
给定一个数组 arr 和一个数 num，请把小于等于 num 的数放在数组的左边，大于 num 的数放在数组的右边。要求：额外空间复杂度 O(1)，时间复杂度 O(N)。
2.1.1 思路转化
首先，设置一个“≤ 区”，在这个区域中的元素都是小于等于给定 num 的。在程序起始阶段，“≤ 区”为空，此时“≤ 区”后面的元素是数组首元素。
此外，还要使用一个变量 i，向后遍历数组。此过程分为两种情况：
-
- arr[i] <= num
- 此时将 arr[i] 和“≤ 区”后面的元素交换，“≤ 区”右扩，i++；
- arr[i] > num
- i++。
- arr[i] <= num
以数组 [3, 5, 4, 7, 6, 3, 5, 8] 为例，分析算法过程（蓝色为 i 指向的元素，红色部分为“≤ 区”）：
（1）[3, 5, 4, 7, 6, 3, 5, 8]
初始状态。此时 3 就是“≤ 区”后面的元素，因此是自己和自己交换。此处容易弄错，需要注意。
3 和自己交换，“≤ 区”右扩，i++。
（2）[3, 5, 4, 7, 6, 3, 5, 8]
5 和自己交换，“≤ 区”右扩，i++。
（3）[3, 5, 4, 7, 6, 3, 5, 8]
4 和自己交换，“≤ 区”右扩，i++。
（4）[3, 5, 4, 7, 6, 3, 5, 8]
不做交换，“≤ 区”不右扩，i++。
（5）[3, 5, 4, 7, 6, 3, 5, 8]
不做交换，“≤ 区”不右扩，i++。
（6）[3, 5, 4, 7, 6, 3, 5, 8]
3 和 7 交换，“≤ 区”右扩，i++。
（7）[3, 5, 4, 3, 6, 7, 5, 8]
5 和 6 交换，“≤ 区”右扩，i++。
（8）[3, 5, 4, 3, 5, 7, 6, 8]
不做交换，“≤ 区”不右扩，i++。
（9）最终结果为 [3, 5, 4, 3, 5, 7, 6, 8]。
2.2 问题二（荷兰国旗问题）
给定一个数组 arr 和一个数 num，请把小于 num 的数放在数组的左边，等于 num 的数放在数组的中间，大于 num 的数放在数组的右边。要求：额外空间复杂度 O(1)，时间复杂度 O(N)。
2.2.1 思路转化
设置一个“＜ 区”，在这个区域中的元素都是小于给定 num 的。在程序起始阶段，“＜ 区”为空，此时“＜ 区”后面的元素是数组首元素。
设置一个“＞ 区”，在这个区域中的元素都是大于给定 num 的。在程序起始阶段，“＞ 区”为空，此时“＞ 区”前面的元素是数组尾元素。
此外，还要使用一个变量 i，向后遍历数组。此过程分为三种情况：
-
- arr[i] < num
- 将 arr[i] 和“＜ 区”后面的元素交换，“＜ 区”右扩，i++；
- arr[i] = num
- i++；
- arr[i] > num
- 将 arr[i] 和“＞ 区”前面的元素交换，“＞ 区”左扩，i 不变；
- arr[i] < num
以数组 [3, 5, 4, 7, 6, 3, 5, 8] 为例，分析算法过程（蓝色为 i 指向的元素，红色部分为“＜ 区”，绿色部分为“＞ 区”）：
（1）[3, 5, 4, 7, 6, 3, 5, 8]
3 和自己交换，“＜ 区右扩”，i++。
（2）[3, 5, 4, 7, 6, 3, 5, 8]
i++。
（3）[3, 5, 4, 7, 6, 3, 5, 8]
4 和 5 交换，“＜ 区右扩”，i++。
（4）[3, 4, 5, 7, 6, 3, 5, 8]
7 和 8 交换，“＞ 区左扩”，i 不变。
（5）[3, 4, 5, 8, 6, 3, 5, 7]
8 和 5 交换，“＞ 区左扩”，i 不变。
（6）[3, 4, 5, 5, 6, 3, 8, 7]
i++。
（7）[3, 4, 5, 5, 6, 3, 8, 7]
6 和 3 交换，“＞ 区左扩”，i 不变。
（8）[3, 4, 5, 5, 3, 6, 8, 7]
3 和 5 交换，“＜ 区右扩”，i++。
（9）最终结果为 [3, 4, 3, 5, 5, 6, 8, 7]。
3. 快速排序
3.1 快排 V1.0
快排 V1.0 和荷兰问题的第一问思路类似。将数组的最后一个元素作为 num，将其前面的元素按“≤ num”和“＞ num”分成两个部分。划分完成后，将 num 和“＞ num”部分的首元素交换。其后，将划分出的两个区域分别递归，重复上述过程。
时间复杂度为 O(N2)。
3.2 快排 V2.0
快排 V2.0 和荷兰问题的第二问思路类似。将数组的最后一个元素作为 num，将其前面的元素按“＜ num”、“= num”和“＞ num”分成三个部分。划分完成后，将 num 和“＞ num”部分的首元素交换。其后，将划分出的“＜ num”和“＞ num”区域分别递归，重复上述过程。
时间复杂度为 O(N2)。
3.3 快排 V1.0 和快排 V2.0 的时间复杂度局限性
不难看出，快排 V1.0 和快排 V2.0 的时间复杂度依赖于 num 的选取。划分值越靠近两侧，复杂度越高。划分值越靠近中间，复杂度越低。对于极端的测试数据，譬如 [1, 2, 3, 4, 5] 这样的数组，时间复杂度为 O(N2)。
改善快速排序的时间复杂度，就要对 num 的选取做文章。这就引出了随即快速排序。
3.4 快排 V3.0（随机快速排序）
3.4.1 随机快速排序原理
在数组范围中，等概率随机选一个数作为划分值 num。根据这个 num 把数组按“＜ num”、“= num”和“＞ num”分成三个部分。划分完成后，将 num 和“＞ num”部分的首元素交换。其后，将划分出的“＜ num”和“＞ num”区域分别递归，重复上述过程。
时间复杂度为O(N*logN)。
3.4.2 随机快速排序示例代码
3.5 快速排序的额外空间复杂度
概率平均情况：O(log N)。
最差情况：O(N)。