剑指 Offer 51. 数组中的逆序对 （ 归并 ）

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

归并排序

老规矩三部曲

1. 分
2. 逻辑处理
3. 并（排序）

第一次逻辑处理的时候， 就已经并过一次排序了

AC Code

class Solution {
    
    
    public int reversePairs(int[] nums) {
    
    
        // 
        int len = nums.length;
        if(len < 2) return 0;
        int ans = devide(nums, 0, len - 1);
        return ans;
    }

    public int devide(int[] nums, int left, int right){
    
    
        if(left >= right) return 0;
        int mid = left + (right - left) / 2;
        // 分 
        int a = devide(nums, left, mid);
        int b = devide(nums, mid + 1, right);
        int res = a + b;

        // 处理
        // 前面一个数字大于后面的数字  >>  结果 + 1
        int s1 = left, s2 = mid + 1;
        while(s1 < mid + 1) {
    
    
            // 最小的两个数，已经排好序了.
            while(s2 <= right && nums[s1] > nums[s2]) {
    
    
                s2++;
            }

            res += s2 - (mid + 1);
            // 下一个数
            s1++;
        }


        // 并  >> 排序
        int[] arr = new int[right - left + 1];
        int l = left, r = mid + 1, idx = 0;
        while(l < mid + 1 || r <= right) {
    
    
            if(l >= mid + 1) {
    
    
                arr[idx++] = nums[r++];
            } else if(r > right) {
    
    
                arr[idx++] = nums[l++];
            } else {
    
    
                if (nums[l] < nums[r]) arr[idx++] = nums[l++];
                else arr[idx++] = nums[r++];
            }
        }

        // 覆盖原数组
        for(int i = 0; i < idx; i++) {
    
    
            nums[left + i] = arr[i];
        }

        return res;
    }

}