算法：归并排序两种实现方式：递归和非递归

递归方式：

/**
     * 迭代方式排序
     */
    public static void mergeSort1(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        //  流程处理
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int left, int right) {
        if (left == right) {
            return;
        }
        //求中点位置
        int mid = left + ((right - left) >> 1);
        //分左边
        process(arr, left, mid);
        //分右边
        process(arr, mid + 1, right);
        //合并
        merge(arr, left, mid, right);
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int[] help = new int[right - left + 1];
        //left position
        int lpos = left;
        //right position
        int rpos = mid + 1;
        //help index
        int i = 0;

        while (lpos <= mid && rpos <= right) {
            help[i++] = arr[lpos] <= arr[rpos] ? arr[lpos++] : arr[rpos++];
        }
        // 当有一个指针越界后的处理
        while (lpos <= mid) {
            help[i++] = arr[lpos++];
        }
        while (rpos <= right) {
            help[i++] = arr[rpos++];
        }
        for (i = 0; i < help.length; i++) {
            arr[left + i] = help[i];
        }
    }

非递归方式：

 // 非递归方法实现
    public static void mergeSort2(int[] arr) {
        if (arr == null && arr.length < 2) {
            return;
        }
        int N = arr.length;
        int mergeSize = 1; //步长
        while (mergeSize < N) {
            int left = 0;
            while (left < N) {
                //检查加上步长后是否越界
                if (left + mergeSize >= N) {
                    break;
                }
                int mid = left + mergeSize - 1;
                int right = Math.min(mid + 1 + mergeSize - 1, N - 1);
                merge(arr, left, mid, right); //merge方法不变
                left = right + 1;
            }
            //防止溢出
            if (mergeSize > N / 2) {
                break;
            }
            mergeSize <<= 1;
        }
    }