归并排序的思想解决逆序对和翻转对问题

剑指 Offer 51. 数组中的逆序对

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例 1:
输入: [7,5,6,4]
输出: 5

代码如下：

//通用解法： 归并排序。时间复杂度高。
class Solution {
    public int reversePairs(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        return mergSort(nums,0,nums.length-1);
    }
    public int mergSort(int[] array,int left,int right) {
        if (left == right) {
            return 0;
        }
        int mid = (left +right) /2;
        return mergSort(array,left,mid)+mergSort(array,mid+1,right)+merge(array,left,mid,right);
    }
    public int merge(int[] array,int left,int mid,int right) {
       int[] tmpArr = new int[right-left+1];
        int num = 0; // 翻转对数量
        int i = left;
        int j = mid+1;
        while (i <= mid) {
            // 此时(i,j)是符合条件的，j在右组中继续向右滑动，继续向右扩，看在此时i不动的情况下，j最多能向右扩到哪里
            while (j <= right && array[i] > array[j]) { // 【注意】：num为整型范围，乘以2可能溢出
                j++;
            }
            // 此时，j来到右组中第一个不满足条件的位置，找到了在此时i的情况下，能产生的翻转对数量：
            num += (j - mid - 1);
            // 此时的i位置已经结算完答案，i向右滑动一个位置，尝试下一个i，能产生多少个翻转对
            i++;
        }
        int s1 = left;
        int s2 = mid+1;
        int k =0;
        while (s1 <= mid && s2 <= right) {
            if (array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        while (s1 <= mid) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= right) {
            tmpArr[k++] = array[s2++];
        }
        for (int h = 0; h < tmpArr.length; h++) {
            array[left++] = tmpArr[h];
        }
        return num;
    }
}

解法二：归并排序思想：
class Solution {
    public int reversePairs(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        return mergSort(nums,0,nums.length-1);
    }
    public int mergSort(int[] array,int left,int right) {
        if (left == right) {
            return 0;
        }
        int mid = (left +right) /2;
        return mergSort(array,left,mid)+mergSort(array,mid+1,right)+merge(array,left,mid,right);
    }
    public int merge(int[] array,int left,int mid,int right) {
       int[] tmpArr = new int[right-left+1];
        int num = 0; // 翻转对数量
        int s1 = left;
        int s2 = mid+1;
        int k =0;
        while (s1 <= mid && s2 <= right) {
            if (array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                num += mid -s1 +1;
                tmpArr[k++] = array[s2++];
            }
        }
        while (s1 <= mid) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= right) {
            tmpArr[k++] = array[s2++];
        }
        for (int h = 0; h < tmpArr.length; h++) {
            array[left++] = tmpArr[h];
        }
        return num;
    }
}

493. 翻转对

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。

你需要返回给定数组中的重要翻转对的数量。

示例 1:
输入: [1,3,2,3,1]
输出: 2

示例 2:
输入: [2,4,3,5,1]
输出: 3

注意:
给定数组的长度不会超过50000。
输入数组中的所有数字都在32位整数的表示范围内。

代码如下：

class Solution {
    public int reversePairs(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        return mergSort(nums,0,nums.length-1);
    }
    public int mergSort(int[] array,int left,int right) {
        if (left == right) {
            return 0;
        }
        int mid = (left +right) /2;
        return mergSort(array,left,mid)+mergSort(array,mid+1,right)+merge(array,left,mid,right);
    }
    public int merge(int[] array,int left,int mid,int right) {
       int[] tmpArr = new int[right-left+1];
        int num = 0; // 翻转对数量
        int i = left;
        int j = mid+1;
        while (i <= mid) {
            // 此时(i,j)是符合条件的，j在右组中继续向右滑动，继续向右扩，看在此时i不动的情况下，j最多能向右扩到哪里
            while (j <= right && array[i] > (long)2*array[j]) { // 【注意】：num为整型范围，乘以2可能溢出
                j++;
            }
            // 此时，j来到右组中第一个不满足条件的位置，找到了在此时i的情况下，能产生的翻转对数量：
            num += (j - mid - 1);
            // 此时的i位置已经结算完答案，i向右滑动一个位置，尝试下一个i，能产生多少个翻转对
            i++;
        }
        int s1 = left;
        int s2 = mid+1;
        int k =0;
        while (s1 <= mid && s2 <= right) {
            if (array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        while (s1 <= mid) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= right) {
            tmpArr[k++] = array[s2++];
        }
        for (int h = 0; h < tmpArr.length; h++) {
            array[left++] = tmpArr[h];
        }
        return num;
    }
}