前言：
前面介绍的几个时间复杂度为 O(n^2)的几个排序算法（选择、插入、冒泡、希尔排序），其中尤为需要注意的是插入排序，在近乎有序的测试用例条件下，此算法的效率会高于O(n*logn)的排序算法，几乎是O(n)，
一、O(n*logn) 和 O(n^2)算法比较：
O(n*logn)可以在1s内轻松处理百万数量级的数据，当n=10^5时，其实这个测试数量也不是很大，O(n*logn)比O(n^2)快6000倍。
二、归并排序：
（1）整体思路：
- 将数组对半划分，分别对左右数组进行排序。
- 继续划分左边，右边的数组，然后继续划分.....直到划到一个只剩下一个元素，开始对每一个小部分进行排序
- 小部分排序完，进行向上归并，就是与旁边的小组进行归并（此时每个小组都是有序的，层层往上归并）
（2）算法复杂度
n个元素每次分两组，log以2为底n，就相当于一个树的高度。每次归并处理都可以看做O(n)的时间复杂度，整个过程O(nlogn)
(3) 代码实现
- i，j分别指向当前正在考虑的元素，
- k最终归并，i和j比较后放入的位置，即表示下一个需要放的位置
- 一个前闭后闭的数组，明确边界的问题
- 复制数组时始终要记住有一个L的偏移量
private static void merge(Comparable[] arr, int l, int mid, int r) {
//Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);
Comparable[] aux = new Comparable[r-l+1];
for(int i = l; i <= r; i ++){
aux[i-l] = arr[i];
}
// l...mid区间和mid+1...r区间
int i = l, j = mid+1;
for(int k = l; k <= r; k++){
if(i > mid){ // 如果左半部分元素已经全部处理完毕
arr[k] = aux[j-l];
j ++;
}else if(j > r){ // 如果右半部分元素已经全部处理完毕
arr[k] = aux[i-l];
i ++;
}else if(aux[i-l].compareTo(aux[j-l]) < 0){
arr[k] = aux[i-l];
i ++;
}else {
arr[k] = aux[j-l];
j ++;
}
}
}
//递归使用归并排序，对arr[l..r]的范围进行排序
private static void sort(Comparable[] arr, int l, int r){
if(l >= r) return;
int mid = (r-l)/2 + l;
sort(arr, l, mid);
sort(arr, mid+1, r);
merge(arr, l, mid, r);
}
public static void sort(Comparable[] arr){
int n = arr.length;
sort(arr, 0, n-1);
}
（4）归并与插入比较
对于无序数组来说，归并肯定好
对于近乎有序的数组，数组越有序，插入排序的时间性能越趋近于O(n)，比归并排序高效
三、归并优化
（1）优化一
所有的排序算法中都存在一种优化，就是递归到底优化。，当递归元素较少时，可以用插入排序来提高性能
- 当待排序的数组元素较少时，近乎有序的情况概率较大，此时插入排序有优势。
- 虽然插入排序的时间复杂度是O(n^2)级别，而归并排序是O(n*logn)，但是别忽视这两者都依赖于常数系数n，当n较小时，插入排序是稍快于归并排序的
所以，在此优化中，在一开始判断递归到底的情况下，设定一定的值（这里设定15），剩下的数组采用插入算法进行排序。
（2）优化二
在merge中，并没有对左右两个部分进行判断在归并，而是一律归并，当左部分的最后一个值小于右部分第一个值的话，此时压根就不需要归并，真个数组都是有序的，直接跳过即可~
注意：归并必须要对logN层进行递归，只是每次发现不需要递归退出来，无法退化成O(N)的算法~
对于改进，数组中存在有序会有一定的效果，但也会阻碍（if语句本身消耗）,但总体不打
四、优化后的代码
总之，就是对sort函数进行优化~
private static void sort(Comparable[] arr, int l, int r){
// 优化1，小规模用插入
if( r - l <= 15){
InsertionSortoptimize.sort(arr, l, r);
return;
}
int mid = (r-l)/2 + l;
sort(arr, l, mid);
sort(arr, mid+1, r);
// 优化2，对于已经有序不进行merger
if(arr[mid].compareTo(arr[mid+1]) > 0){
merge(arr, l, mid, r);
}
}
实验证明，确实是比较好，这种优化更加实用与几乎有序的数组排序~