归并排序（Merge Sort），又称二路归并排序，是指将一个数组一分为二，对每一个子数组递归排序，最后将排好的子数组合并为一个有序数组的过程。归并排序，是“分治法”应用的完美实现。
From Wikipedia：https://en.wikipedia.org/wiki/Merge_sort
1. 归并排序图示
2. 归并排序流程
通过图示，可以发现归并排序一共只需要两个步骤：
- 分：将原数组分为n个子数组，每个子数组长度为1（长度为1的数组自然有序）。
- 合：依次将两个相邻的有序数组，合并成一个有序数组，重复操作直至剩下一个有序数组。
3. 代码实现
归并排序的代码逻辑还是很容易看懂的，数组两分，左右递归，难点在于“合”这一步骤：
public abstract class BasicMergeSort implements Sort {
@Override
public void sort(int[] array) {
sort(array, 0, array.length - 1);
}
private void sort(int[] array, int left, int right) {
if (left < right) {
int mid = (left + right) >>> 1;
sort(array, left, mid);
sort(array, mid + 1, right);
merge(array, left, mid, right);
}
}
protected abstract void merge(int[] array, int left, int mid, int right);
}
合并两个有序数组（长度分别为 n 和 m），可以开辟一个长度为 m+n 的新数组。
使用两个指针记录数组位置，依次比较指针位置的数字，将较小的数字放入新数组。这样可以在线性的时间内完成合并工作。
public final class MergeSort1 extends BasicMergeSort {
@Override
protected void merge(int[] array, int left, int mid, int right) {
int[] newArray = new int[right - left + 1];
int startIndex1 = left;
int startIndex2 = mid + 1;
for (int i = 0; i < newArray.length; ++i) {
if (startIndex1 == mid + 1) {
newArray[i] = array[startIndex2++];
} else if (startIndex2 == right + 1) {
newArray[i] = array[startIndex1++];
} else {
newArray[i] = array[startIndex1] < array[startIndex2] ? array[startIndex1++] : array[startIndex2++];
}
}
System.arraycopy(newArray, 0, array, left, newArray.length);
}
}
4. 归并排序的时间复杂度和空间复杂度
显而易见，递归的次数为 m = log2n，合并操作的时间消耗是线性的，所以时间复杂度 T(n) 如下：
空间复杂度为O(n).
5. 空间复杂度为 O(1) 的归并排序
归并排序中，合并的步骤可以采取直接插入排序（因为前半部分已经有序，所以直接插入排序的效率很高）。
如此一来，可以将空间复杂度由 O(n) 降低至 O(1)，然而相对的时间复杂度则由 O(nlog2n) 升至 O(n^2)。
public final class MergeSort2 extends BasicMergeSort {
@Override
protected void merge(int[] array, int left, int mid, int right) {
for (int i = mid + 1; i <= right; ++i) {
int cur = array[i];
boolean flag = false;
for (int j = i - 1; j >= left; --j) {
if (cur < array[j]) {
array[j + 1] = array[j];
} else {
array[j + 1] = cur;
flag = true;
break;
}
}
if (!flag) {
array[left] = cur;
}
}
}
}
6. 归并排序的性能分析及优化
两种归并排序的算法，分别是采取了空间换时间，及时间换空间的策略，其性能各有优劣，但是通过分析可以得出以下特点：
- 计算机对于频繁开辟小数组空间的消耗，比开辟等价大的单个数组空间，代价要来的更大。
- 使用直接插入排序（从1/2处开始），由于拥有较小的最高次幂系数，其性能在长度 n 较小的时候，与 T(n) = O(log2n) 相差不大。
根据以上两个性质，可以在归并排序中，设置一个阈值。
超过这个给定的阈值，则采取空间换时间的策略；反之，采用时间换空间的策略，从而提高归并排序的效率。
public class MixedMergeSort implements Sort {
private int threshold = 2 << 4;
private BasicMergeSort sort1 = new MergeSort1();
private BasicMergeSort sort2 = new MergeSort2();
public int getThreshold() {
return threshold;
}
public void setThreshold(int threshold) {
this.threshold = threshold;
}
@Override
public void sort(int[] array) {
sort(array, 0, array.length - 1);
}
private void sort(int[] array, int left, int right) {
if (left < right) {
int mid = (left + right) >>> 1;
sort(array, left, mid);
sort(array, mid + 1, right);
if (right - left > threshold) {
sort1.merge(array, left, mid, right);
} else {
sort2.merge(array, left, mid, right);
}
}
}
}
Source Code: https://github.com/Gerrard-Feng/algorithm-learning.git