剑指 offer 51 数组中的逆序对

剑指 offer 51 数组中的逆序对

超时版

class Solution {
     
     public int reversePairs(int[] nums) {
     
        if (nums.length==0){
     
            return 0;
        }
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
     
            for (int j=i+1;j<nums.length;j++){
     
                if (nums[i]>nums[j]){
     
                    res++;
                }
            }

        }
        return res;
    }
}

时间复杂度$O(n^2)$。
空间复杂度$O(1)$。

分治

class Solution {
     
     public int reversePairs(int[] nums) {
     
        if(nums.length==0){
     
            return 0;
        }
        int[] tmp = new int[nums.length];
        return sub(nums,0,nums.length-1,tmp);
    }


    public int sub(int[] nums,int l,int r,int[] tmp){
     
        if (l==r){
     
            return 0;
        }
        int mid = l+(r-l)/2;

        //分治
        int lRes = sub(nums,l,mid,tmp);
        int rRes = sub(nums,mid+1,r,tmp);
        //合并
        //左，右子部分已经排好序
        //nums是有序的
        // int[] tmp = new int[nums.length];
        for (int i = l; i <=r; i++) {
     
            tmp[i] = nums[i];
        }
        if(tmp[mid]<=tmp[mid+1]){
     
            return lRes+rRes;
        }
        int count = 0;
        int p1 = mid;
        int p2 = r;
        int p3 = r;
        //num放排好序的
        while (p1>=l && p2>=mid+1){
     
            if (tmp[p1]>tmp[p2]){
     
                count+=(p2-mid);
                nums[p3]=tmp[p1];
                p3--;
                p1--;
            }else{
     
                nums[p3--]=tmp[p2--];
            }
        }
        while (p1>=l){
     
            nums[p3--]=tmp[p1--];
        }
        while (p2>=mid+1){
     
            nums[p3]=tmp[p2];
            p3--;
            p2--;
        }
        return lRes+rRes+count;
    }

}

时间复杂度$O(n\log n)$，同归并排序。
时间复杂度$O(n\log n)$，同归并排序，因为归并排序需要用到一个临时数组。

离散化树状数组

没看懂。。。。