排序笔记_4（自上而下、自底而上的归并排序）

/***
 * 归并排序（分治思想的典型应用）：
 * 
 * 分为自上而下（递归）和自下而上（非递归，比较适合用链表组织的数据）的算法
 * 
 * 特点：
 * 
 * 保证将任意长度为N的数组排序所需的时间和NlogN成正比；
 * 处理有百万、千万级别的元素个数的数组不成问题。
 * 
 * 缺点：
 * 
 * 需要的额外空间和N成正比。
 * 
 * 改进方案：
 * ①对小规模的子数组使用插入排序
 * ②测试数组是否有序
 * （加一个判断条件，如果a[mid]小于a[mid+1]，我们就认为是有序的，
 * 从而跳过merge()方法，这个改动不会影响递归的调用，但是运行时间就变成线性的了。）
 * 
 * 自上而下（递归）：
 * 将一个大问题分割成小问题分别解决，然后用所有小问题的答案解决大问题的答案。
 * 
 * 自下而上（非递归）：
 * 先归并那些微型数组，然后再成对归并得到的子数组，直到将整个数组归并到一块。
 * （基本思想：首先进行两两归并，把每个元素看成一个大小为1的子数组，
 * 然后是四四归并，将两个大小为2的数组归并成一个有4个元素的数组，
 * 然后是八八归并，一直下去。）
 */
package com.chapter_two;

/***
 * 自顶向下的归并排序
 * 
 * @author LuodiJack
 * 
 */
public class Merge {
    @SuppressWarnings("rawtypes")
    private static Comparable[] aux;// 辅助数组

    /***
     * 原地归并的抽象方法： 将两个有序数组归并成更大的有序数组。
     * 
     * @param a
     *            需要归并的数组。
     * @param low
     *            数组的下界，实际的索引值。
     * @param mid
     *            数组的中部，实际的索引值。
     * @param high
     *            数组的上界，实际的索引值。
     */
    @SuppressWarnings("rawtypes")
    private static void merge(Comparable[] a, int low, int mid, int high) {
        int i = low;
        int j = mid + 1;
        for (int k = low; k <= high; k++) {
            aux[k] = a[k];
        }

        for (int k = low; k <= high; k++) {
            if (i > mid) {// 右边剩下，将右边赋值给数组。
                a[k] = aux[j++];
            } else if (j > high) {// 左边剩下，将左边赋值给数组。
                a[k] = aux[i++];
            } else if (Template.less(aux[i], aux[j])) {// 左边的小，就取左边的。
                a[k] = aux[i++];
            } else {// 右边的小，就取右边的。
                a[k] = aux[j++];
            }
        }
    }

    /***
     * 自顶向下的归并排序函数
     * 
     * @param a
     *            需要排序的数组
     * 
     */
    @SuppressWarnings("rawtypes")
    public static void sort(Comparable[] a) {
        aux = new Comparable[a.length];// 一次性的分配辅助空间
        sort(a, 0, a.length - 1);
    }

    @SuppressWarnings("rawtypes")
    private static void sort(Comparable[] a, int low, int high) {
        if (high <= low) {
            return;
        }
        int mid = low + (high - low) / 2;
        sort(a, low, mid);// 对左边的归并排序
        sort(a, mid + 1, high);// 对右边的归并排序
        merge(a, low, mid, high);// 合并两边的数组
    }

}

package com.chapter_two;

/***
 * 自底而上的归并排序
 * 
 * @author LuodiJack
 * 
 */
public class MergeBU {
    @SuppressWarnings("rawtypes")
    private static Comparable[] aux;// 辅助数组

    /***
     * 原地归并的抽象方法： 将两个有序数组归并成更大的有序数组。
     * 
     * @param a
     *            需要归并的数组。
     * @param low
     *            数组的下界，实际的索引值。
     * @param mid
     *            数组的中部，实际的索引值。
     * @param high
     *            数组的上界，实际的索引值。
     */
    @SuppressWarnings("rawtypes")
    private static void merge(Comparable[] a, int low, int mid, int high) {
        int i = low;
        int j = mid + 1;
        for (int k = low; k <= high; k++) {
            aux[k] = a[k];
        }

        for (int k = low; k <= high; k++) {
            if (i > mid) {// 右边剩下，将右边赋值给数组。
                a[k] = aux[j++];
            } else if (j > high) {// 左边剩下，将左边赋值给数组。
                a[k] = aux[i++];
            } else if (Template.less(aux[i], aux[j])) {// 左边的小，就取左边的。
                a[k] = aux[i++];
            } else {// 右边的小，就取右边的。
                a[k] = aux[j++];
            }
        }
    }

    /***
     * 自底向上的归并排序函数
     * 
     * @param a
     *            需要排序的数组
     * 
     */
    @SuppressWarnings("rawtypes")
    public static void sort(Comparable[] a) {// 进行两两归并
        int N = a.length;
        aux = new Comparable[a.length];// 一次性的分配辅助空间
        for (int sz = 1; sz < N; sz = sz + sz) {// sz子数组大小
            for (int low = 0; low < N - sz; low += sz + sz) {// low: 子数组索引
                merge(a, low, low + sz - 1, Math.min(low + sz + sz - 1, N - 1));
            }
        }
    }

}