简单排序算法实现——归并排序

归并排序(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标定，该下标与前四个下标无关独立，是始终递增的下标。

	private static <AnyType extends Comparable<? super AnyType>>
	void Merge(AnyType[] a, AnyType[] tmpArray, int leftPos, int rightPos, int rightEnd){
		int leftEnd=rightPos-1;//通过该步计算得出A数组的结束位置，由此4个下标完全指定AB数组
		int tmpPos=leftPos;//该下标指定temp数组操作位置，始终递增.
		int numElements=rightEnd-leftPos+1;
		
		while(leftPos<=leftEnd&&rightPos<=rightEnd){
			if(a[leftPos].compareTo(a[rightPos])<0)
				tmpArray[tmpPos++]=a[leftPos++];
			else	tmpArray[tmpPos++]=a[rightPos++];
		}
		
		//B数组已经用尽，A数组有剩余
		while(leftPos<=leftEnd){
			tmpArray[tmpPos++]=a[leftPos++];
		}
		
		//A数组已经用尽，B数组有剩余
		while(rightPos<=rightEnd){
			tmpArray[tmpPos++]=a[rightPos++];
		}
		
		for(int i=0;i<numElements;i++,rightEnd--)
			a[rightEnd]=tmpArray[rightEnd];
	}

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

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

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

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

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

public驱动方法代码如下：

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

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

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