演算法：

要將一個數組排序，可以先（遞迴地）將它分成兩半分別排序，然後將結果歸併起來。

歸併排序最吸引人的性質是它能夠保證將任意長度為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