稳定的归并排序

1. 思路

把整个数组分成不同的小段

2. 过程

每次分割为两部分，log2n次。
每次内部 使用一个help数组，原左部分和原右部分左侧相比，谁小谁放到help中，对应部分起始位置++，
知道一方全部放入，另一方直接加入到help数组中，再更新到原数组上。

3. 代码

   public static void mergeProcess(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = L + (R - L) / 2;
        mergeProcess(arr, L, mid);
        mergeProcess(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    /**
     * 归并排序，非递归实现
     * 外循环，步长两倍递增，O(logN)
     * 内循环，L为每组左组起点，左组范围[L,M] 右组范围[M+1,N]
     * M=L+step-1
     * N=Math.min(M+step,N-1)
     *
     * @param arr 1 2 5 9 7 2 3 1
     *            0 1 2 3 4 5 6 7
     *            L
     */
    public static void mergeProcess2(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        int step = 1;
        //当步长不足N
        while (step < N) {
            //每组左边界
            int L = 0;
            //如果左边界> arr.length了，就退出
            while (L < N) {
                //每一次范围分为左右组  左组[L,M],右组[M+1,N]
                //[0,7]   [0,3][4,7] 步长为4  M=L+step-1
                //        [L,M][M+1,N] N=Math.min(M+step,N-1)

                int M = L + step - 1;
                if (M > N) {
                    break;
                }
                //每组右边界
                int R = Math.min(M + step, N - 1);
                merge(arr, L, M, R);
                //新的左边界=右边界+1
                L = R + 1;
            }
            if (step > N / 2) {
                //步长超过一半就退出
                break;
            }
            step *= 2;
        }
    }


    public static void merge(int[] arr, int L, int mid, int R) {
        //辅助数组
        int[] help = new int[R - L + 1];
        //当前数组的位置
        int helpIndex = 0;
        //原数组左部分起始位置
        int leftIndex = L;
        //原数组右部分起始位置 mid就不行
        int rightIndex = mid + 1;

        //当左右两侧都还有数组，没有越界时
        while (leftIndex <= mid && rightIndex <= R) {
            help[helpIndex++] = arr[leftIndex] < arr[rightIndex] ? arr[leftIndex++] : arr[rightIndex++];
        }

        //当右边越界
        while (leftIndex <= mid) {
            help[helpIndex++] = arr[leftIndex++];
        }

        //当左边越界
        while (rightIndex <= R) {
            help[helpIndex++] = arr[rightIndex++];
        }
        helpIndex = 0;
        //排好序的部分归还原数组
        for (int i = L; i <= R; i++) {
            arr[i] = help[helpIndex++];
        }
    }

4. 时间复杂度O(n*log2n)

根据master公式计算，O=O(n)+2O(n/2)=O(n*logn)