归并排序（非递归）

package com.dtg.javatest;

public class Main01 {

    public static int count = 0;

    public static void main(String[] args) {
        int[] arr = {1, 9, 3, 22, 10, 8, 4, 5, 99, 31, 3332, 2, 19, 322, 544, 29, 103, 56, 28};
        System.out.println(arrstr(arr));

        sort1(arr);

        System.out.println(arrstr(arr));

        System.out.println("count:" + count);
    }


    
    //非递归
    public static void sort1(int[] arr) {

        if (arr == null || arr.length < 2) { //数量少于2 ，则为0或1时，直接返回该数组
            return;
        }

        int AL = 0; //数组最左边
        int AR = arr.length - 1;//数组最右边

        //已知步长和起始位置，可以将原数组拆分为多个子数组，每个子数组可分成左右两个有序数组。        int curstartindex = 0;
        int steplen = 1;

        //步长
        //以下逻辑主要是判断能否拆成一对左右数组， 左数组个数可以比右数组多。 但右数组不能为0个。
        while (steplen <= AR) { //如果步长为AR ，则M坐标为0+AR-1, 右数据起始点为M+1为AR 仍可以分成两数组。 如果步长为AR+1，则不能分出两数组

            int L = curstartindex;//最左边

            int M = curstartindex + steplen - 1;//中间

            int R = (curstartindex + steplen * 2 - 1);//最右边
            R = R < AR ? R : AR;//最右

            if (L >= AR || M >= AR) {
                //L>=AR表示，L已经是原数组最大index, 这样右子数组 是空，L数据与右空数组全并，最后也是L ,所以跳出当前循环
                //M>=AR表示，M已经是原数组最大index, 这样右子数组 是空，所以跳出当前循环
                curstartindex = 0;
                steplen = steplen * 2;
                System.out.println(arrstr(arr));
                continue;
            }

            merge(arr, L, M, R); //拆成两组[L,M] [M+1,R]进行合并排序
            curstartindex = R + 1;//操作完之后， 重新进行当轮下一对左右子组的拆解，合并

        }

    }

  

    public static void merge(int[] arr, int L, int M, int R) {

        String baselog = "merge(" + L + "," + M + "]," + R + ") " + "{" + arrstr(arr, L, M, R) + "}";
        int[] result = new int[R - L + 1];

        int LP = L;
        int RP = M + 1;
        System.out.println(baselog + "LP：" + LP + ",RP:" + RP);

        int i = 0;
        while (LP <= M && RP <= R) {
            count++;
            result[i++] = arr[LP] < arr[RP] ? arr[LP++] : arr[RP++];
        }

        while (LP <= M) {
            count++;
            result[i++] = arr[LP++];
        }

        while (RP <= R) {
            count++;
            result[i++] = arr[RP++];
        }
        for (int k = L; k <= R; k++) {
            count++;
            arr[k] = result[k - L]; //result数组的起始位置0 对应原数据是L，原数组 比 result数组多了L的偏移
        }
        //System.out.println(baselog+"arrstr(arr)："+arrstr(arr));
        System.out.println(baselog + "arrstr(result):" + arrstr(result));

    }

    public static String arrstr(int[] arr) {
        StringBuffer sb = new StringBuffer();

        for (int i : arr) {
            sb.append(String.valueOf(i)).append(" ");
        }
        return sb.toString();
    }

    public static String arrstr(int[] arr, int L, int M, int R) {
        StringBuffer sb = new StringBuffer();

        for (int i = L; i <= R; i++) {
            sb.append(String.valueOf(arr[i])).append(" ");
            if (i == M) {
                sb.append(" M ");
            }
        }
        return sb.toString();
    }
}