BM20 数组中的逆序对

类似归并排序，时间复杂度O(nlog(n))，空间复杂度O(n)
每层都是O(n), 执行了log(n)层，所以时间复杂度是O(nlog(n))，空间复杂度最多也就是创建一个=原数组长度的空间，所以空间复杂度为O(n)，中间临时创建的小数组都会merge过程中销毁，这部分空间不计。

public class Solution {
    int result = 0;
    public int InversePairs(int [] array) {
        if (array == null || array.length < 2) {
            return 0;
        }
        int start = 0, end = array.length - 1;
        partion(array, start, end);
        return result;
    }

    private void partion(int [] array, int start, int end) {
        if (start >= end) {
            return;
        }
        int mid = (end - start) / 2 + start;

        //分组
        partion(array, start, mid);
        partion(array, mid + 1, end);

        //排序
        merge(array, start, mid, end);
    }

    private void merge(int[] array, int start, int mid, int end) {
        int[] temp =  new int[end - start + 1];
        // 两个指针， i从头跑， j从中间的右一个跑, 小的值给k
        int i = start, j = mid + 1, k = 0;
        while (i <= mid && j <= end) {
            if (array[i] < array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
                result = (result + (mid - i + 1)) % 1000000007;
            }
        }

        while (i <= mid) {
            temp[k++] = array[i++];
        }
        while (j <= end) {
            temp[k++] = array[j++];
        }
        for (int w = 0; w < end - start + 1;
                w++) { //将合并好的数组再复制回nums，以保证有序。
            array[start + w] = temp[w];
        }
    }
}

1. i == r+1 当前半段已经统计完，剩下后半段归并，证明 j 后的数都是比 nums [m] 大的，无需统计 j == l+1
2. 当后半段统计完，剩下前半段归并，i 后的数都比 num [l] 大，但在之前已经统计个数，无需统计