归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(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)。