「这是我参与2022首次更文挑战的第28天，活动详情查看：2022首次更文挑战」。
一、分析
时间复杂度：O(N*logN)
核心原理：
- 找到中间数M
- 左边有序
- 右边有序
- merge整体有序
利用Master公式推导归并排序时间复杂度
merge过程：
因为左边有序，右边有序，定义两个指针，分别指向初始位置，谁小拷贝谁（相等就先拷贝左边的），然后谁小移动谁。
两个指针不回退，merge过程时间复杂度O(N)
merge分析过程：
非递归实现思路：
步长 = 1，左部分（长度为1）和右部分（长度为1）merge
步长 = 2，左部分（长度为2）和右部分（长度为2）merge
步长 = 4，左部分（长度为4）和右部分（长度为4）merge
步长 = 8，左部分（长度为8）和右部分（长度为8）merge
步长 = 16，左部分（长度为16）和右部分（长度为16）merge
......
总共需要多少次：logN
步长凑不够两两一组，则跳过，不merge，进行下一次的步长两两配对
步长不够，也merge，不够就不够
每次调整一遍，时间复杂度O(N)，整体时间复杂度：O(N * logN)
左组：L ~ M
右组：M+1 ~ (M+步长)够 或 (N-1)不够
二、实现
// 递归方法实现
public static void mergeSort1(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
process(arr, 0, arr.length - 1);
}
// 请把arr[L..R]排有序
// l...r N
// T(N) = 2 * T(N / 2) + O(N)
// O(N * logN)
public static void process(int[] arr, int L, int R) {
if (L == R) { // base case
return;
}
int mid = L + ((R - L) >> 1);
process(arr, L, mid);
process(arr, mid + 1, R);
merge(arr, L, mid, R);
}
public static void merge(int[] arr, int L, int M, int R) {
int[] help = new int[R - L + 1];
int i = 0;
int p1 = L;
int p2 = M + 1;
while (p1 <= M && p2 <= R) {
help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
// 要么p1越界了，要么p2越界了
while (p1 <= M) {
help[i++] = arr[p1++];
}
while (p2 <= R) {
help[i++] = arr[p2++];
}
for (i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
}
// 非递归方法实现
public static void mergeSort2(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int N = arr.length;
// 步长
int mergeSize = 1;
while (mergeSize < N) { // log N
int L = 0; // 当前左组的，第一个位置
while (L < N) {
int M = L + mergeSize - 1;
if (M >= N) {
break;
}
int R = Math.min(M + mergeSize, N - 1);
merge(arr, L, M, R);
L = R + 1;
}
if (mergeSize > N / 2) { // 防止溢出
break;
}
mergeSize <<= 1;
}
}
三、总结
归并排序递归核心：
- 整体是递归
- 左边排好序
- 右边排好序
- merge让整体有序
归并排序非递归核心：
- 步长
- 扣边界
