归并排序

归并排序是一种稳定排序，归并时需要两两比较，遇到等值时将位置在前的置前即保持相对顺序。时间复杂度是0(nlogn)。

public class MergeSort 
{
	public MergeSort(){}
	
	public static void merge(int[] array,int start,int mid,int end,int[] arraySorted,String rule)
	{
		int i=start;
		int j=mid+1;
		int k=0;
		int[] temp = array.clone();
		while(i<=mid && j<=end)
		{
			if(rule.equalsIgnoreCase("increase"))
			{
				if(array[i]<=array[j]) temp[k++] = array[i++];
				else temp[k++] = array[j++];
			}
			if(rule.equalsIgnoreCase("decrease"))
			{
				if(array[i]>=array[j]) temp[k++] = array[i++];
				else temp[k++] = array[j++];
			}
		}
		while(i<=mid)
			temp[k++] = array[i++];
		while(j<=end)
			temp[k++] = array[j++];
		for(int m=0;m<k;m++)
			arraySorted[start+m] = temp[m];
	}
	
	public static void mergeSort(int[] array,int start,int end,int[] arraySorted,String rule)
	{
		
		if(start == end)
			arraySorted[start] = array[start];
		else if(start < end)
		{
			int[] temp = array.clone();
			int mid = (start+end)/2;
			mergeSort(array,start,mid,temp,rule);
			mergeSort(array,mid+1,end,temp,rule);
			merge(temp,start,mid,end,arraySorted,rule);
		}
	}
	
	public static int[] sort(int[] array,String rule)
	{
		if(!rule.equalsIgnoreCase("increase") && !rule.equalsIgnoreCase("decrease"))
		{	
			System.out.println("Please input the right define of rule: [increase] or [decrease]!");
			System.exit(-1);
		}
		int[] arraySorted = array.clone();
		mergeSort(array,0,array.length-1,arraySorted,rule);
		return arraySorted;
	}
	
	private static void print(int[] array)
	{
		for(int i=0;i<array.length;i++)
		{
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	
	public static void main(String[] args)
	{
		int[] array = new int[]{1,10,3,5,2,4,9,11};
		int[] arraySort = sort(array,"increase");
		System.out.println("Before sort:");
		print(array);
		System.out.println("After sort:");
		print(arraySort);
	}
}