归并排序

前面写了简单排序，平均时间复杂度是平方级的，这里介绍归并排序，比较次数在1/2NlgN到NlgN，空间复杂度O（n）。

归并用的是分治递归思想，将大问题化为更小的子问题，直到数组个数为1时不能再分，此时两合并，四四合并。。。

下面是自顶向下的归并排序实现：

public class Merge {

    private static int[] temp;

    public static void sort(int[] a) {
        temp = new int[a.length];
        int mid = (a.length - 1) / 2;
        sort(a, 0, mid, a.length - 1);
    }

    private static void sort(int[] a, int lo, int mid, int h) {
        if (h <= lo) return;
        sort(a, lo, lo + (mid - lo) / 2, mid);
        sort(a, mid + 1, mid + (h - mid) / 2, h);
        merge(a, lo, mid, h);

    }

    private static void merge(int[] a, int lo, int mid, int h) {
        int k = lo, j = mid + 1;
        for (int i = lo; i <= h; i++) {
            temp[i] = a[i];
        }

        for (int i = lo; i <= h; i++) {
            if (k > mid) a[i] = temp[j++];
            else if (j > h) a[i] = temp[k++];
            else if (temp[j] < temp[k]) a[i] = temp[j++];
            else a[i] = temp[k++];
        }
    }
}

递归自顶向下往往分为递推和回溯的过程，从根向子问题的过程，同样也可以自底向上用循环解决。

public static void sort(int[] a) {
        temp=new int[a.length];
        int wth = 1;
        for (; wth < a.length; wth += wth) {
            for (int j = 0; j < a.length -wth; j += 2 * wth) {
                merge(a, j, j + wth-1, Math.min(j +2* wth-1,a.length-1));
            }
        }
    }