Algs4-2.2.11 改进的Merge排序

Problem:

对归并排序做如下优化：
- 加快小数组排序
- 检测数组是否已经有序
- 通过在递归中交换参数避免数组复制。

Code:

package sed.algorithm.chapter2.section2;


import edu.princeton.cs.introcs.StdOut;
import edu.princeton.cs.introcs.StdRandom;

public class ImprovingMerge {

    public static void sort(Comparable[] a){
        //aux 数组用于辅助队a的排序
        Comparable[] aux = new Comparable[a.length];
        //对aux数组进行初始化
        System.arraycopy(a, 0, aux, 0, a.length);
        sort(a, aux, 0, a.length - 1);

    }

    //输入的各参数中我们认为aux数组已经是半幅有序的了。
    private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi ){

        //当字数组大小小于特定值时用插入排序，避免小数组上无效率的递归归并
        if (hi-lo <= 7) {
            insertionSort(a,lo,hi);
            return; 
        }
        if(hi <= lo) return;
        int mid = lo+(hi -lo)/2;

        //在子排序中交换 a, 和 aux的角色以消除不必要的复制
        sort(aux, a, lo, mid);
        sort(aux, a, mid+1, hi);
        //如果aux数组部分已经是有序的，那么将其对应部分复制给a
        if (!less(aux[mid+1], aux[mid])) {
            System.arraycopy(aux, lo, a, lo, hi-lo+1);
            return ;
        }
        //从aux数组归并到a数组
        merge(a, aux, lo, mid, hi);
    }

    public static void insertionSort(Comparable[] a, int lo, int  hi){

        for (int i = lo; i <= hi; i++) {
            //一开始此处的额j>lo写成了j>0 这个bug用了好长时间才找到
            for (int j = i; j > lo && less(a[j], a[j-1]); j--) {
                exch(a, j, j - 1);
            }
        }
    }

    public static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi){
        int i = lo, j = mid+1;

        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++) {
            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;
    }

    public static Comparable[] generateArray(int N){
        Comparable[] array = new Comparable[N];
        for (int i = 0; i < array.length; i++) {
            array[i]=StdRandom.uniform();
        }

        return array;
    }

    public static void main(String[] args) {


        for (int i = 1; i <= 1024; i++) {
            Comparable[] a = generateArray(i);
            sort(a);
            if (!isSorted(a)) {
                show(a);
                System.out.println("You know!");
                break;
            }
        }

    }

}

Notes:

 递归的思想不是很好理解，有时候总是让人感觉到隔着一层什么东西。这恐怕要大量的练习和思考才能真正明白。
 化繁为简，分而治之。一定要有一个基本的可解决的子问题，而整个问题的解决可以划归到解决这个子问题上来。