2-路归并排序的递归实现和 非递归实现

递归版

归并排序是基于归并的思想，2-路归并排序的原理就是将要排序的序列两两归并。
举个栗子，将以下的序列从小到大排序：
{4，3，2，1}
对于这个序列，
1—–首先分成{4，3} 和{2，1}组内进行单独排序，得到{3，4}和{1，2}
2—– 合并成序列{3，4，1，2} 然后组内再进行单独排序， 得到{1，2，3，4}。 算法结束

基于这个简单的思想:
一下给出Java的实现:

import java.util.Scanner;
public class Main {
    public static int maxn = 100000+10;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- != 0) {
            int n = in.nextInt();
            int[] A = new int[n];
            for (int i = 0; i < n; i++) {
                A[i] = in.nextInt();
            }

            mergeSort(A, 0, n-1);
            for (int i = 0; i < n; i++) {
                System.out.println(A[i]);
            }
        }

    }
    public static void mergeSort(int[] A, int left, int right) {
        if (left < right) {
            int mid = (left+right)/2;
            mergeSort(A, left, mid);
            mergeSort(A, mid+1, right);
            merge(A, left, mid, mid+1, right);
        }
    }
    public static void merge(int[] A, int l1, int r1, int l2, int r2) {
        int i = l1, j =l2;
        int[] temp = new int[maxn];
        int index = 0;
        while (i <= r1 && j <= r2) {
            if (A[i] <= A[j]) {
                temp[index++] = A[i++];
            } else {
                temp[index++] = A[j++];
            }
        }
        while (i <= r1) temp[index++] = A[i++];
        while (j <= r2) temp[index++] = A[j++];
        for (i = 0; i < index; i++) {
            A[l1+i] = temp[i];//将合并后的序列赋值回数组
        }
    }
}

非递归版

令步长step初值2，然后将数组中每step个元素作为一组，将其内部进行排序（左边step/2个，右边step/2个）;再令step*2，重复操作;

public class Main {
    public static int maxn = 100000+10;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- != 0) {
            int n = in.nextInt();
            int[] A = new int[n];
            for (int i = 0; i < n; i++) {
                A[i] = in.nextInt();
            }

            mergeSort(A, n);
            for (int i = 0; i < n; i++) {
                System.out.println(A[i]);
            }
        }

    }
//  public static void mergeSort(int[] A, int left, int right) {
//      if (left < right) {
//          int mid = (left+right)/2;
//          mergeSort(A, left, mid);
//          mergeSort(A, mid+1, right);
//          merge(A, left, mid, mid+1, right);
//      }
//  }
    //非递归实现
    //数组从0开始
    public static void mergeSort(int[] A, int n) {
        //step 为组内元素个数, step/2 是左区间元素个数
        for (int step = 2; step/2 <= n-1; step *= 2) {
            for (int i = 0; i <= n-1; i += step) {
                int mid = i + step/2-1;
                if (mid < 0) mid = 0;//第一个元素数组下标是0，需要特判考虑
                if (mid+1 <= (n-1)) {
                    //左区间为[i, mid], 右区间为[mid+1, Math.min(i+step-1, n)]
                    merge(A, i, mid, mid+1, Math.min(i+step-1, n-1));
                }
            }
        }
    }
    //数组从1 开始
//  public static void mergeSort(int[] A, int n) {
//      //step 为组内元素个数, step/2 是左区间元素个数
//      for (int step = 2; step/2 <= n; step *= 2) {
//          for (int i = 1; i <= n; i += step) {
//              int mid = i + step/2-1;
////                if (mid < 0) mid = 0;
//              if (mid+1 <= n) {
//                  //左区间为[i, mid], 右区间为[mid+1, Math.min(i+step-1, n)]
//                  merge(A, i, mid, mid+1, Math.min(i+step-1, n-1));
//              }
//          }
//      }
//  }
    public static void merge(int[] A, int l1, int r1, int l2, int r2) {
        int i = l1, j =l2;
        int[] temp = new int[maxn];
        int index = 0;
        while (i <= r1 && j <= r2) {
            if (A[i] <= A[j]) {
                temp[index++] = A[i++];
            } else {
                temp[index++] = A[j++];
            }
        }
        while (i <= r1) temp[index++] = A[i++];
        while (j <= r2) temp[index++] = A[j++];
        for (i = 0; i < index; i++) {
            A[l1+i] = temp[i];//将合并后的序列赋值回数组
        }
    }
}