归并排序

归并排序(Merge Sort) 是一种采用了分治(Divide and Conquer) 想法的排序算法。

该算法中基本的操作是合并两个已经排序的表，并将输出放到第三个表中，该过程可以通过对输入数据一趟排序来完成。

基本的合并算法是取两个输入数组A和B，一个输出数组C，与三个计数器Actr，Bctr，Cctr，它们初始置于对应数组的开始端。

A[Actr]和B[Bctr]中的较小者被复制到C中的下一个操作位置，相关的Actr或Bctr向前推进一步。

当两个输入表中有一个用完的时候，则将另一个表中剩余部分拷贝到C中。

合并两个已排序的表的时间显然是线性的，因为最多进行N-1次比较。

这一过程体现的是"治"的思想，该部分的java代码实现如下，数组A与数组B在概念上被leftPos,leftEnd,rightPos,rightEnd四个下标标定，数组C是一开始在下面会提到的public驱动方法里创建的tmpArray数组。 tmpArray里的操作位置由下标tmpPos标定，该下标与前四个下标无关独立，是始终递增的下标。

[java] view plain copy

1. private static <AnyType extends Comparable<? super AnyType>>  
2. void Merge(AnyType[] a, AnyType[] tmpArray, int leftPos, int rightPos, int rightEnd){  
3.     int leftEnd=rightPos-1;//通过该步计算得出A数组的结束位置，由此4个下标完全指定AB数组  
4.     int tmpPos=leftPos;//该下标指定temp数组操作位置，始终递增.  
5.     int numElements=rightEnd-leftPos+1;  
6.       
7.     while(leftPos<=leftEnd&&rightPos<=rightEnd){  
8.         if(a[leftPos].compareTo(a[rightPos])<0)  
9.             tmpArray[tmpPos++]=a[leftPos++];  
10.         else    tmpArray[tmpPos++]=a[rightPos++];  
11.     }  
12.       
13.     //B数组已经用尽，A数组有剩余  
14.     while(leftPos<=leftEnd){  
15.         tmpArray[tmpPos++]=a[leftPos++];  
16.     }  
17.       
18.     //A数组已经用尽，B数组有剩余  
19.     while(rightPos<=rightEnd){  
20.         tmpArray[tmpPos++]=a[rightPos++];  
21.     }  
22.       
23.     for(int i=0;i<numElements;i++,rightEnd--)  
24.         a[rightEnd]=tmpArray[rightEnd];  
25. }  

对于一开始的“分”的过程，可以用以下代码实现：

[java] view plain copy

1. private static <AnyType extends Comparable<? super AnyType>>  
2. void MergeSort(AnyType[] a, AnyType[] tmpArray, int left, int right){  
3.     //当left==right的时候，  
4.     //已经划分到单个元素的基本情况，无需再分，可递归返回执行merge操作  
5.     if(left<right){  
6.         int center=(left+right)/2;  
7.         //对left~center，center+1~right 再进行细分。  
8.         MergeSort(a,tmpArray,left,center);  
9.         MergeSort(a,tmpArray,center+1,right);  
10.           
11.         //left是A数组的开始下标，center+1是B数组开始下标，right是B数组结束下标  
12.         //实际上在Merge中通过计算还要得到一个A数组的结束下标。  
13.         Merge(a,tmpArray,left,center+1,right);  
14.     }  
15. }  

整体的可再分的一个判断条件是left<right，当该条件不满足，即left==right时，表明已经分到了最基本的单个元素的情况，此时递归栈开始返回，各个阶段的Merge操作被执行。在每一步的MergeSort阶段并没有做实际的数组操作，因此MergeSort的唯一作用是不断地判定left，center，right的值，将数组在逻辑概念上不断二分，但是知道递归栈返回执行Merge方法之前，数组都没有实际的变化。

以上的方法都是private的，唯一暴露在外的public方法用作以驱动，在该方法中要构建一个tmpArray辅助数组，作为临时的C数组被使用。

另外，a，tmpArray都是采用传引用方法被传递的，因此都在同一块内存上操作，每Merge完一次，数组a都会有实际的变化。

public驱动方法代码如下：

[java] view plain copy

1. public class MergeSort{   
2.     public static <AnyType extends Comparable<? super AnyType>>  
3.     void MergeSort(AnyType[] a){  
4.         AnyType[] tmpArray=(AnyType[]) new Comparable[a.length];  
5.           
6.         MergeSort(a,tmpArray,0,a.length-1);  
7. }  

归并算法的平均时间复杂度为O(nlogn).

附图一张，以供理解记忆：

http://blog.csdn.net/a454042522/article/details/8554035