5.2：归并排序的非递归实现

归并排序的非递归实现（步骤详解）：

    // 归并排序的非递归实现
public class MergeSort {
    public static void mergeSort2(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr);
    }

    public static void process(int[] arr) {
        int N = arr.length;
        // 步长
        int mergeSize = 1;
        while (mergeSize < N) {
            int L = 0;
            while (L < N) {
                // 越界条件的判断
                if (mergeSize >= N - L) {
                    break;
                }
                // L + mergeSize也有可能越界，所以有了上面的代码
                int mid = L + mergeSize - 1;
                /*
                根据越界条件的判断，mid小于N
                if (mid > N) {
                   break;
                }
                */
                // 有左半部分
                int R = Math.min((mid + mergeSize), (N - 1));
                merge(arr, L, mid, R);
                L = R + 1;
            }
            // 防止数字越界溢出，导致死循环。
            if (mergeSize > (N / 2)) {
                break;
            }
            mergeSize *= 2;
        }
    }

    public static void merge(int[] arr, int L, int mid, int R) {
        int[] help = new int[R - L + 1];
        int p1 = L;
        int p2 = mid + 1;
        int i = 0;
        while (p1 <= mid && p2 <= R) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        // 后面两个循环只会执行一个，因为P1,P2并不是同时走的
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[L + j] = help[j];
        }
    }
}

防溢出设计：

当数组的长度非常大时，step*2可能会越界，比如超出整数范围，这样step就会变成负数，这样的话程序就出现错误

当数组长度 N 是偶数时：当step = (N/2) 时就已经可以,此时step < N

当数组长度 N 是奇数时：当step = (N/2)*2 时才可以,此时step < N

即 step小于N就已经排好序了

if (step > N / 2) { // 这个地方不可以写成 （step * 2 > N，这样写铁定step * 2越界)
break;
}

注意边界条件，等号可不可以加，当step是偶数时，step == N / 2 时，就刚好有序

当step是奇数时，step == N / 2还没有序，只有当step = ( N / 2) * 2 时才有序，所以先不可以break,然后进行

step = step * 2这时在进行一系列操作之后就刚好有序，这时再进行溢出判断，step > N / 2, 这样就可以停下了。