归并排序

算法：

    要将一个数组排序，可以先（递归地）将它分成两半分别排序，然后将结果归并起来。

    归并排序最吸引人的性质是它能够保证将任意长度为N的数组排序所需时间和NlogN成正比；它的主要缺点则是它所需的额外空间和N成正比。

 

复杂度：

    对于长度为N的任意数组，自顶向下的归并排序需要1/2NlgN至NlgN次比较。

    对于长度为N的任意数组，自顶向下的归并排序最多需要访问数组6NlgN次。2N次用来复制，2N次用来将排好序的元素移动回去，另外最多比较2N次。

    对于长度为N的任意数组，自底向上的归并排序需要1/2NlgN至NlgN次比较，最多访问数组6NlgN次。

    没有任何基于比较的算法能够保证使用少于lg(N!)-NlgN次比较将长度为N的数组排序。

    归并排序是一种渐进最优的基于比较排序的算法。

 

代码：

    

public class Merge {
    private static Comparable []aux;
    public static void sort(Comparable[] a){
        aux = new Comparable[a.length];
        sort(a,0,a.length-1);
    }
    private static void sort(Comparable[]a, int lo,int hi){
        if (hi<=lo) return ;
        int mid = lo+(hi-lo)/2;
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);
    }
    public static void merge(Comparable[] a,int lo, int mid, int hi){
        int i =lo,j=mid+1;
        for(int k = lo;k<=hi;k++){
            aux[k]=a[k];
        }
        for (int k = lo;k<=hi;k++){
            if (i>mid) a[k]=aux[j++];
            else if (j>hi) a[k]=aux[i++];
            else if(less(aux[j],aux[i])) a[k]=aux[j++];
            else  a[k] =aux[i++];
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[]a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    private static void show(Comparable[] a)
    {
        for (int i = 0;i<a.length;i++){
            System.out.println(a[i]+" ");
        }
    }
    private static boolean isSorted(Comparable []a){
        for (int i =1 ;i <a.length;i++){
            if(less(a[i],a[i-1]))
                return false;
        }
        return true;
    }
   
    public static void main(String [] args){
        Integer a[] ={1,5,3,2,6,8};

        sort(a);
        assert isSorted(a);
        show(a);
    }
}

public class MergeBU {
    private static Comparable[] aux;
    public static void sort(Comparable[]a){
        int N = a.length;
        aux = new Comparable[a.length];
        for (int sz =1;sz<N;sz=sz+sz){
            for(int lo=0;lo<N-sz;lo+=sz+sz){
                merge(a,lo,lo+sz-1,Math.min(lo+sz+sz-1,N-1));
            }
        }

    }
    public static void merge(Comparable[] a,int lo, int mid, int hi){
        int i =lo,j=mid+1;
        for(int k = lo;k<=hi;k++){
            aux[k]=a[k];
        }
        for (int k = lo;k<=hi;k++){
            if (i>mid) a[k]=aux[j++];
            else if (j>hi) a[k]=aux[i++];
            else if(less(aux[j],aux[i])) a[k]=aux[j++];
            else  a[k] =aux[i++];
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[]a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    private static void show(Comparable[] a)
    {
        for (int i = 0;i<a.length;i++){
            System.out.println(a[i]+" ");
        }
    }
    private static boolean isSorted(Comparable []a){
        for (int i =1 ;i <a.length;i++){
            if(less(a[i],a[i-1]))
                return false;
        }
        return true;
    }
    public static void main(String [] args){
        Integer a[] ={1,5,3,2,6,8};

        sort(a);
        assert isSorted(a);
        show(a);
    }
}

参考资料：

    《算法》-Sedgewick