归并排序

　　归并排序算法是用分治策略实现对n个元素进行排序的算法。

　　其基本思想是：将待排序的元素分成大小大致相同的两个子集合，分别对2个子集合进行排序，最终将排序好的子集合合并成为所要求的排好序的集合。

递归版本算法(不完全版本)：

public static void mergeSort(Comparable a[],int left,int right){
        if(left<right){//至少有两个元素
            int i=(left+right)/2;    //取中点
            mergeSort(a,left,i);
            mergeSort(a, i+1, right);
            merge(a,b,left,right);   //合并到数组b
            copy(a,b,left,right);    //复制回数组a
        }
}

非递归版本实现：

　　可以看出，算法mergeSort的递归过程只是将待排序集合一分为二，直至待排序的集合只剩下一个元素为止。然后不断合并2个排序好的子集合。

　　由此可以想到，我们可以先将数组a中相邻元素两两配对。用合并算法将他们排序，构成n/2组长度为2的排好序的子集合，然后将它们排序成长度为4

的子集合，如此继续下去，直至整个数组排好序。

　　这样一来就可以消除递归了。

　　

public class MergeSort {
    
    // 非递归版本归并排序
    @SuppressWarnings("rawtypes")
    public static void mergeSort(Comparable[] a) {
        Comparable b[] = new Comparable[a.length];
        int s = 1;
        while (s < a.length) {
            // a,b交替保证了a一直是有序的
            mergePass(a, b, s);
            s = s * 2;
            mergePass(b, a, s);
            s = s * 2;
        }
    }

    @SuppressWarnings("rawtypes")
    private static void mergePass(Comparable[] x, Comparable[] y, int s) {
        // 合并大小为s的相邻子数组
        int i = 0;
        while (i + 2 * s <= x.length) {
            // 合并大小为s的相邻2段子数组，x[i,i+s-1]，x[i+s-1,i+2*s-1]
            merge(x, y, i, i + s - 1, i + 2 * s - 1);
            i = i + 2 * s;
        }

        if (i + s < x.length) {
            // 剩下的元素个数大于s小于2s,仍然要合并
            merge(x, y, i, i + s - 1, i + 2 * s - 1);
        } else {
            // i+s>=x.length的时候，此时剩余的元素个数小于s， 当小于s的时候已经是有序的，直接把剩余元素添加到y的末尾
            for (; i < y.length; i++)
                y[i] = x[i];
        }
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private static void merge(Comparable[] copy, Comparable[] to, int left,
            int middle, int right) {
        // 合并copy[left,middle]和to[middle+1,right]到to[left,right]
        int i = left, j = middle + 1, k = left;

        while (i <= middle && j <= right) {
            if (copy[i].compareTo(copy[j]) <= 0) // 由小到大排序
                to[k++] = copy[i++];
            else
                to[k++] = copy[j++];
        }

        /*
         * 以下两个循环用于将剩下已经有序的元素添加到to的末尾， 其中一个数组最大的元素n已经在to中，另外一个数组的元素肯定大于等于n，
         * 因此直接添加就行
         */
        while (i <= middle)
            to[k++] = copy[i++];
        while (j <= right)
            to[k++] = copy[j++];
    }

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {
        Comparable a[] = { 4, 6, 7, 1, 2, 5, 9, 0 };
        mergeSort(a);
        for (int i = 0; i < a.length; i++)
            System.out.print(" "+a[i]);
    }

}