本文已参与[新人创作礼]活动，一起开启掘金创作之路。
今天我们继续，下面讲解的是归并排序算法，从算法思路，到算法伪代码实现，到复杂度分析，从这里开始我们手把手搭建一个测试平台的基础，根据你自身硬件水平可以对下列代码进行从1000，到千万级测试，其中算法测试时间与你的机器硬件水平和实现的算法有关系，下面是归并算法的具体讲解。
（1）排序算法的思路并且举例说明
基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。 例如：
初始序列：7 3 5 2 1 6
第一次排序： 3 7 2 5 1 6
第二次排序： 2 3 7 1 5 6
第三次排序： 1 2 3 5 6 7
（2）算法伪代码
Merge( T A,T &B, s,m,e)//将A中的A[s..m]和A[m+1..e]合并成B[s..e]
{
for( j = m+1,k = s; j <=e && s<= m;k++)
{
if( A[j] < A[s] ) B[k] = A[j++];
esle B[k] = A[s++];
}
if( s <= m ) B[k..e] = A[s..m];
if( j <= e) B[k..e] = A[j..e];
}
（3）复杂度分析
平均时间复杂度：O(nlog2n)
易得时间复杂度： T（n）=2T（n/2）+θ（n）
解：
T(n)=aT(n/b)+f(n) a>=1 b>1 f(n)>0 n>n0
a =2,b=2 f(n)=θ（1）>0 n^logba=n^log22=n
f(n)=θ（1）=θ(（lgn）^k * 1) k=0时
T(n)=θ(（lgn）^k+1 * n^logba)=θ(nlgn)
当有n个记录时，需进行[log2n]趟归并排序,每一趟归并,其关键字比较次数不超过n,元素移动次数都是n,因此,归并排序的时间复杂度为O(nlog2n)。
最好时间复杂度：O(nlog2n)
最差时间复杂度：O(nlog2n)
空间复杂度：O(n)
用顺序表实现归并排序时，需要和待排序记录个数相等的辅助存储空间，所以空间复杂度为O(n);
稳定性：稳定
（4）代码主体部分
package runoob;
import java.util.Arrays;
/**
* 归并排序
*/
public class MergeSort {
// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
private static void merge(Comparable[] arr, int l, int mid, int r) {
Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);// 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
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++;
}
}
}
private static void sort(Comparable[] arr, int l, int r) {// 递归使用归并排序,对arr[l...r]的范围进行排序
if (l >= r) {
return;
}
int mid = (l + r) / 2;
sort(arr, l, mid);
sort(arr, mid + 1, r);
// 对于arr[mid] <= arr[mid+1]的情况,不进行merge
// 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
if (arr[mid].compareTo(arr[mid + 1]) > 0)
merge(arr, l, mid, r);
}
public static void sort(Comparable[] arr) {
int n = arr.length;
sort(arr, 0, n - 1);
}
// 测试MergeSort
public static void MergeSort_text(long num) {//单独测试归并
Integer[] arr = SortHelper.generateRandomArray(num, 0, 100);
long start=System.nanoTime();
sort(arr);
long end=System.nanoTime();
System.out.println("花费时间:" + (end - start)/1000 + "(ms)");
System.out.println("下面是排序好的数列");
SortHelper.printArray(arr);
}
对应代码中的SortHelper类我们留一个小小的悬念，留到最后来进行叙说，其中目前来说他的方法generateRandomArray的参数为，（num，left，right）第一个参数参与算法生成的数量级，作为随机生成序列，它可以为千万，因为是long级别，left和right则为生成序列的大小范围，生成的序列为返回值类型为Integer[]。
（5）测试结果如下：
笔者有兴趣可以尝试千万级的算法测试，这里便不在赘述。
