归并排序

 

        归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

 

        首先考虑下如何将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

       代码如下：

 

	/**
	 * 将两个有序数列合并成一个有序数列
	 * @param a
	 * @param b
	 * @return
	 */
	public static int[] mergeArray(int[] a,int[] b){ 
		int i=0;
		int j=0;
		int k=0;
		int[] temp = new int[a.length+b.length];
		
		while(i<a.length&&j<b.length){
			if(a[i]<b[j])
				temp[k++] = a[i++];
			else
				temp[k++] = b[j++];			
		}
		
		while(i<a.length)
			temp[k++] = a[i++];
		
		while(j<b.length)
			temp[k++] = a[j++];
		
		return temp;
	}

 

        上述代码说明如下：

        假设我们有两个已经排序好的子序列。

               序列A：1 23 34 65

               序列B：2 13 14 87

       那么可以按照下面的步骤将它们归并到一个序列中。

             （1）首先设定一个新的数列C[8]。

             （2）A[0]和B[0]比较，A[0] = 1，B[0] = 2，A[0] < B[0]，那么C[0] = 1

             （3）A[1]和B[0]比较，A[1] = 23，B[0] = 2，A[1] > B[0]，那么C[1] = 2

             （4）A[1]和B[1]比较，A[1] = 23，B[1] = 13，A[1] > B[1]，那么C[2] = 13

             （5）A[1]和B[2]比较，A[1] = 23，B[2] = 14，A[1] > B[2]，那么C[3] = 14

             （6）A[1]和B[3]比较，A[1] = 23，B[3] = 87，A[1] < B[3]，那么C[4] = 23

             （7）A[2]和B[3]比较，A[2] = 34，B[3] = 87，A[2] < B[3]，那么C[5] = 34

             （8）A[3]和B[3]比较，A[3] = 65，B[3] = 87，A[3] < B[3]，那么C[6] = 65

             （9）最后将B[3]复制到C中，那么C[7] = 87。归并完成。

        可以看出合并有序数列的效率是比较高的，可以达到O(n).

 

        解决了上面合并有序数列问题，再来看归并排序就比较简单了。

        其基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

        可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。

        这样通过先递归的分解数列，再合并数列就完成了归并排序。

        算法如下图所示：

 
   

     

     代码实现如下：

 

public class MergeSort {
	
	public static void main(String[] args) {
		int[] a = {10,4,6,3,8,2,5,7}; 
		mergeSort(a,0,7);
		
		System.out.println("------------------");
		print(a);
	}
	
	public static void mergeSort(int[] a,int first,int last){
		
		if(first<last){
			int mid = (first+last)/2;
			mergeSort(a,first,mid);
			mergeSort(a,mid+1,last);
			merge(a,first,mid,last);
			System.out.print("本次递归："+first+" "+mid+" "+last+":  ");
			print(a);
			System.out.println();
		}
		
	}
	
	private static void merge(int[] a,int first,int mid,int last) {
		int i = first;
		int j = mid+1;
		int k = 0;
		int[] temp = new int[a.length];
		while(i<=mid&&j<=last){
			if(a[i]<a[j])
				temp[k++] = a[i++];
			else
				temp[k++] = a[j++];
		}
		
		while(i<=mid)
			temp[k++] = a[i++];
		
		while(j<=last)
			temp[k++] = a[j++];
		
		//再把临时空间的元素拷到a上
		for(int t=0;t<k;t++)
			a[first+t] = temp[t];//注：不是a[t] = temp[t],因为数组是按引用传递，不是按值传递
	}

}

 其输出结果如下：

 

本次递归：0 0 1:  4 10 6 3 8 2 5 7 
本次递归：2 2 3:  4 10 3 6 8 2 5 7 
本次递归：0 1 3:  3 4 6 10 8 2 5 7 
本次递归：4 4 5:  3 4 6 10 2 8 5 7 
本次递归：6 6 7:  3 4 6 10 2 8 5 7 
本次递归：4 5 7:  3 4 6 10 2 5 7 8 
本次递归：0 3 7:  2 3 4 5 6 7 8 10 
------------------
2 3 4 5 6 7 8 10 

     其代码实现和结果分析如下：

        复杂度分析：

        归并排序是稳定的，它的最差，平均，最好时间都是O(nlogn)。但是它需要额外的存储空间，这在某些内存紧张的机器上会受到限制。

        归并算法是又分割和归并两部分组成的。对于分割部分，如果我们使用二分查找的话，时间是O(logn)，在最后归并的时候，时间是O(n)，所以总的时间是O(nlogn)。