用Java写算法之归并排序

时间:2024-09-29 21:04:26

转自;http://flyingcat2013.blog.51cto.com/7061638/1281026

前面的三种排序算法(冒泡排序,选择排序,插入排序)在平均情况下均为O(n^2)复杂度,在处理较大数据的时候比较吃力。现在来说说相对快速一些的算法,例如下面的归并排序。

算法概述/思路

归并排序是基于一种被称为“分治”(divide and conquer)的策略。其基本思路是这样的:

1.对于两个有序的数组,要将其合并为一个有序数组,我们可以很容易地写出如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//both a and b is ascend.
public void merge(int[] a, int[] b, int[] c){
    int i=0,j=0,k=0;
    while (i<=a.length && j<=b.length){
        if (a[i]<=b[i]){
            c[k++]=a[i++];
        }
        else{
            c[k++]=b[j++];
        }
    }
    while (i<=a.length){
        c[k++]=a[i++];
    }
    while (j<=b.length){
        c[k++]=b[j++];
    }
}

容易看出,这样的合并算法是高效的,其时间复杂度可达到O(n)。

2.假如有一个无序数组需要排序,但它的两个完全划分的子数组A和B分别有序,借助上述代码,我们也可以很容易实现;

3.那么,如果A,B无序,怎么办呢?可以把它们再分成更小的数组。

4.如此一直划分到最小,每个子数组都只有一个元素,则可以视为有序数组。

5.从这些最小的数组开始,逆着上面的步骤合并回去,整个数组就排好了。

总而言之,归并排序就是使用递,先分解数组为子数组,再合数组。

下面是归并排序的示意图(图片来自*):

用Java写算法之归并排序

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//归并排序
    public static void mergeSort(int[] arr){
        int[] temp =new int[arr.length];
        internalMergeSort(arr, temp, 0, arr.length-1);
    }
    private static void internalMergeSort(int[] a, int[] b, int left, int right){
        //当left==right的时,已经不需要再划分了
        if (left<right){
            int middle = (left+right)/2;
            internalMergeSort(a, b, left, middle);          //左子数组
            internalMergeSort(a, b, middle+1, right);       //右子数组
            mergeSortedArray(a, b, left, middle, right);    //合并两个子数组
        }
    }
    // 合并两个有序子序列 arr[left, ..., middle] 和 arr[middle+1, ..., right]。temp是辅助数组。
    private static void mergeSortedArray(int arr[], int temp[], int left, int middle, int right){
        int i=left;     
        int j=middle+1;
        int k=0;
        while ( i<=middle && j<=right){
            if (arr[i] <=arr[j]){
                temp[k++] = arr[i++];
            }
            else{
                temp[k++] = arr[j++];
            }
        }
        while (i <=middle){
            temp[k++] = arr[i++];
        }
        while ( j<=right){
            temp[k++] = arr[j++];
        }
        //把数据复制回原数组
        for (i=0; i<k; ++i){
            arr[left+i] = temp[i];
        }
    }

需要说明的是,在合并数组的时候需要一个temp数组。我们当然有足够的理由在每次调用的时候重新new一个数组(例如,减少一个参数),但是,注意到多次的创建数组对象会造成额外的开销,我们可以在开始就创建一个足够大的数组(等于原数组长度就行),以后都使用这个数组。实际上,上面的代码就是这么写的。

算法性能/复杂度

归并排序的效率是很高的,由于递归划分为子序列只需要logN复杂度,而合并每两个子序列需要大约2n次赋值,为O(n)复杂度,因此,只需要简单相乘即可得到归并排序的时间复杂度
O(㏒n)。并且由于归并算法是固定的,不受输入数据影响,所以它在最好、最坏、平均情况下表现几乎相同,均为O(㏒n)。

但是,归并排序最大的缺陷在于其空间复杂度。从上面的代码可以看到,在合并子数组的时候需要一个辅助数组,然后再把这个数据拷贝回原数组。所以,归并排序的空间复杂度(额外空间)为O(n)。可不可以省略这个数组呢?不行!如果取消辅助数组而又要保证原来的数组中数据不被覆盖,那就必须要在数组中花费大量时间来移动数据。不仅容易出错,还降低了效率。因此这个辅助空间是少不掉的。

算法稳定性

因为我们在遇到相等的数据的时候必然是按顺序“抄写”到辅助数组上的,所以,归并排序同样是稳定算法。

算法适用场景

归并排序在数据量比较大的时候也有较为出色的表现(效率上),但是,其空间复杂度O(n)使得在数据量特别大的时候(例如,1千万数据)几乎不可接受。而且,考虑到有的机器内存本身就比较小,因此,采用归并排序一定要注意。