递归和迭代两种方式实现归并排序（Java版）

递归版

package MergeSort;

import Utils.SortUtils;
/**
 * 归并排序递归版
 * @author liguodong
 */

public class Demo02 {

    public static void mergeSort(int[] a){
        mSort(a, a, 0, a.length-1);
    }
    /**
     * 
     * @param SR为待排序的数据
     * @param TR1为排序之后的数据
     * @param s
     * @param t
     */
    public static void mSort(int[] SR,int[] TR1, int s,int t){
        int m;
        int[] TR2 = new int[SR.length];

        if(s==t){
            TR1[s] = SR[s];
        }else {
            m = (s+t)/2;//4
            mSort(SR, TR2, s, m);
            mSort(SR, TR2, m+1, t);
            merge(TR2, TR1, s, m, t);//0 4 8
        }

    }

    //归并两个有序的数组
    /**
     * @param SR 有两个有序数组
     * @param TR 将SR的两个有序数组合并为一个数组TR
     * @param i
     * @param m
     * @param n
     */
    public static void merge(int[] SR,int[] TR,int i,int m,int n){
        int j,k,l;

        //i(0~4) j(5~8)
        for(j=m+1,k=i; i<=m && j<=n; k++){

            if(SR[i]<SR[j]){
                TR[k] = SR[i++];
            }else{
                TR[k] = SR[j++];
            }
        }


        if(i<=m){
            for (l = 0; l <= m-i ; l++) {
                TR[k+l] = SR[i+l];
            }
        }

        if(j<=n){
            for (l = 0; l <= n-j; l++) {
                TR[k+l] = SR[j+l];
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {2,3,5,4,1,6,9,8,7};
        mergeSort(a);
        SortUtils.printString(a);
    }
}

复杂度分析

迭代版

package MergeSort;
import Utils.SortUtils;

/**
 * 递归排序迭代版
 * @author liguodong
 *
 */

public class Demo03 {

    public static void mergeSort(int[] a){
        int[] TR = new int[a.length];//用于存放归并结果

        int k=1;//起始，子序列长度为1
        while(k<a.length){
            mergePass(a, TR, k, a.length);//将原先无序的数据两两归并入TR
            k = 2*k;//子序列长度加倍
            mergePass(TR, a, k, a.length);//将TR中已经两两归并的有序序列再归并回数组a
            k = 2*k;//子序列长度加倍
        }
    }

    public static void mergePass(int[] SR, int [] TR,int s,int len){

        int i=0;
        while (i < len-2*s+1) {//8
            merge(SR,TR,i,i+s-1,i+2*s-1);//两两归并
            i=i+2*s;
        }

        //处理最后的尾数
        //i=8
        if(i< len-s+1){//9
            merge(SR, TR, i, i+s-1, len-1);//归并最后两个序列
        }else {
            for (int j = i; j < len; j++) {//若最后只剩下单个子序列
                TR[j] = SR[j];
            }
        }   
    }

    public static void merge(int[] SR,int[] TR,int i,int m,int n){
        int j,k,l;

        //i(0~4) j(5~8)
        for(j=m+1,k=i; i<=m && j<=n; k++){

            if(SR[i]<SR[j]){
                TR[k] = SR[i++];
            }else{
                TR[k] = SR[j++];
            }
        }


        if(i<=m){
            for (l = 0; l <= m-i ; l++) {
                TR[k+l] = SR[i+l];
            }
        }

        if(j<=n){
            for (l = 0; l <= n-j; l++) {
                TR[k+l] = SR[j+l];
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {2,3,5,4,1,6,9,8,7,10,20,45,32,28,44,31,55,43,23,21,23,21,33,21};
        mergeSort(a);
        SortUtils.printString(a);
    }
}