力扣逆序对问题（改写归并排序）

题目链接：力扣

 题目大意：

        给定一个数组nums，任意i，j位置（i<j）如果满足nums[i] > nums[j]，则（i，j）算作一对逆序对，问：整个数组有多少组逆序对？

        看到这个题，很容易就想到暴力方法，枚举所有的（i，j）位置，判断是否满足逆序对，最后返回统计的逆序对结果。但是这种方法的时间复杂度是O（n^2），要是暴力方法可以解决的话，这个题又怎么会在LeetCode上被划分为“困难”等级？显然暴力枚举会超时：

 归并排序解决：时间复杂度O（n*logn）

        归并排序的大概流程：先有一个merge函数使得L...R上有序，在调用递归函数使得整体L...R有序，在归并排序函数里调用这个递归函数，实现数组整体有序。那么归并排序和这个题有什么关联？

        统计逆序对的问题本质就是遍历数组，寻找当前数的右边有多少个数比自己小，统计所有满足的情况并返回。

        关键在于归并排序的merge过程。原始归并排序merge过程：左指针从L位置开始、右指针从mid+1位置开始，判断左指针和右指针对应的数哪个小，拷贝小的那个数到辅助数组，直到遍历完左半部分和右半部分，再将辅助数组的值拷贝回原始数组L...R位置。

        改写归并排序的merge过程：左指针指向mid，右指针指向R（从右往左遍历，向辅助数组拷贝的时候也是从右往左），如果左指针对应的值 > 右指针对应的值，拷贝左指针的值到辅助数组（从右往左拷贝），同时计数右边有多少个比当前值小。直到左半边数组、右半边数组拷贝完全。再把辅助数组的值拷贝给原始数组L...R。

merge函数代码如下：

    public static int merge(int[] arr, int L, int mid, int R) {
        int left = mid;
        int right = R;
        int count = 0;
        int[] help = new int[R - L + 1];
        int index = help.length - 1;
        while (left >= L && right >= mid + 1) {
            count += arr[left] > arr[right] ? (right - mid) : 0;
            help[index--] = arr[left] > arr[right] ? arr[left--] : arr[right--];
        }
        while (left >= L && right < mid + 1) {
            help[index--] = arr[left--];
        }
        while (left < L && right >= mid + 1) {
            help[index--] = arr[right--];
        }
        for (int i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
        return count;
    }

 解决这个题的整体代码：

    public static int reversePairs1(int[] nums) {
        if (nums == null || nums.length < 2) {
            return 0;
        }
        return process(nums, 0, nums.length - 1);
    }

    public static int process(int[] arr, int L, int R) {
        if (L >= R) {
            return 0;
        }
        int mid = L + ((R - L) >> 1);
        return process(arr, L, mid) + process(arr, mid + 1, R) + merge(arr, L, mid, R);
    }

    public static int merge(int[] arr, int L, int mid, int R) {
        int left = mid;
        int right = R;
        int count = 0;
        int[] help = new int[R - L + 1];
        int index = help.length - 1;
        while (left >= L && right >= mid + 1) {
            count += arr[left] > arr[right] ? (right - mid) : 0;
            help[index--] = arr[left] > arr[right] ? arr[left--] : arr[right--];
        }
        while (left >= L && right < mid + 1) {
            help[index--] = arr[left--];
        }
        while (left < L && right >= mid + 1) {
            help[index--] = arr[right--];
        }
        for (int i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
        return count;
    }