归并排序

这里一共实现了两个版本的归并排序，一个自顶而下，一个自底而上

归并排序（自顶而下）

实现原理：将两个已经排序好的数组合并成一个数组也是有序的。

优点：能保证将任意长度为N的数组排序所需要的时间和NlogN成正比

缺点：所需的额外空间和N成正比

实现代码如下：

import edu.princeton.cs.algs4.StdOut;

public class Merge {
    private static Comparable[] aux;
    private static void merge(Comparable[] a, int lo, int mid ,int hi){
        int i = lo;
        int 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[i],aux[j]))
                a[k] = aux[i++];
            else
                a[k] = aux[j++];
        }
    }
    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) {
        // TODO Auto-generated method stub
        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 show(Comparable[] a){
        for(int i = 0;i<a.length;i++)
            StdOut.print(a[i] + " ");
        StdOut.println();
    }
    public static boolean isSorted(Comparable[] a){
        for(int i = 1;i<a.length;i++)
            if(less(a[i],a[i-1]))
                return false;
        return true;
    }
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] a = {"c","tian", "4","w", "678", "qg"};
        sort(a);
        show(a);
    }

}

归并排序（自底而上）

自底向上的归并排序比较适合用链表组织的数据，不需要创建新的链表实现原地排序，因为数据都保存在数据变量中

代码实现如下：

import edu.princeton.cs.algs4.StdOut;

public class MergeBU {

    private static Comparable[] aux;
    public static void sort(Comparable[] a){
        int N = a.length;
        aux = new Comparable[N];
        for(int sz = 1; sz < N; sz = sz + sz)
            for(int lo = 0; lo < N - sz; lo += sz + sz)//lo要小于N-sz,因为数组有可能不是2的幂，如果lo在N-sz和N-sz-sz之间，在进行一次不对称的归并
                merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N-1));
        }

    private static void merge(Comparable[] a, int lo, int mid ,int hi){
        int i = lo;
        int 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[i],aux[j]))
                a[k] = aux[i++];
            else
                a[k] = aux[j++];
        }
    }
    public static void show(Comparable[] a){
        for(int i = 0;i<a.length;i++)
            StdOut.print(a[i] + " ");
        StdOut.println();
    }
    public static boolean isSorted(Comparable[] a){
        for(int i = 1;i<a.length;i++)
            if(less(a[i],a[i-1]))
                return false;
        return true;
    }
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] a = {"c","tian", "4","w", "678", "qg"};
        sort(a);
        show(a);
    }

}