493. Reverse Pairs

主要是归并排序中的关键思想情况

如何设计归并排序merger(int []nums, int lstart, int lend, int rstart, int rend){

注意lstart 到lend 是有序的情况 ， rstart 到rend 也是有序的情况

}

如果 lstart 大于 rstart的话，那么lstart 到lend 都是要比rstart 大的数，（在这个时候进行统计计数即可情况）进行合并排序的情况，rstart ++ (就可以往后面进行移动操作了), 主要是针对这种情况，不要有遗漏的情况出现即可，

如果lstart< rstart 这样的操作的话，不需要进行统计计数，直接放入中间数组情况即可

比如上面 左边那部分的情况

左边的元素情况为 [1,3,5,7] 右边元素情况为 [2,4,6,8]
如果lstart 走到3，lend =7 , rstart =2, rend=8,
如果要查找 左边都比 rstart大于2的元素，则 一共3对 ，(3,2)、(5,2)和（7，2 ），一共三对， 然后 rstart 向右边继续走，走到3这里，所以在这里左边比2大都统计完了，这样就不会溜掉

统计公式
count += lend-lstart +1 这个就是统计的时候的部分

1. 最后关于如何将中间数组的结果复制到 原来数组中，让原来数组中的元素情况按照有序的情况进行排序
   最后是将中间数组的长度为原始数组的长度一样的长度，

num[lstart, lend, rstart, rend] 数组长度为rend-lstart +1,
对应的中间数组 tmp[------ lstart, lend, rstart, rend -------]— 符号的地方数组中间结果不赋值，

归并排序

在归并排序的基础上面做，
类似于三部曲的情况，
1.主函数

代码

最后的成形代代码，这个是针对 nums[i]>nums[j], 只是大而已， 493是num[i]>2* nums[j]大于两倍的概念情况

public class Solution {
    /**
     * @param A an array
     * @return total of reverse pairs
     */
    public long reversePairs(int[] A) {
        return mergeSort(A, 0, A.length - 1);
    }
    
    private int mergeSort(int[] A, int start, int end) {
        if (start >= end) {
            return 0;
        }
        
        int mid = (start + end) / 2;
        int sum = 0;
        sum += mergeSort(A, start, mid);
        sum += mergeSort(A, mid+1, end);
        sum += merge(A, start, mid, end);
        return sum;
    }
    
    private int merge(int[] A, int start, int mid, int end) {
        int[] temp = new int[A.length];
        int leftIndex = start;
        int rightIndex = mid + 1;
        int index = start;
        int sum = 0;
        
        while (leftIndex <= mid && rightIndex <= end) {
            if (A[leftIndex] <= A[rightIndex]) {
                temp[index++] = A[leftIndex++];
            } else {
                temp[index++] = A[rightIndex++];
                sum += mid - leftIndex + 1;
            }
        }
        while (leftIndex <= mid) {
            temp[index++] = A[leftIndex++];
        }
        while (rightIndex <= end) {
            temp[index++] = A[rightIndex++];
        }
        
        for (int i = start; i <= end; i++) {
            A[i] = temp[i];
        }
        
        return sum;
    }
}

上述代码参考了九章算法，

就章算法

关于归并排序在刷题中的作用，可以查看我GitHub上面的一个总结
归并思想总结

进一步优化(简化代码空间结构情况)

上面使用到了一个辅助数组，空间辅助度为O(n)， 也可以不使用中间数组，数组Arrays.sort(数组，开始位置，截止位置)(不包括截止位置的情况)，对lstart 到rend 这边的数组元素进行排序，

493 大于两倍的情况

关键
有两种计数方式

1. 统计左边的
2. 统计右边的()

有两种对数组进行排序的算法可以选择
1.使用辅助数组，类似归并排序，这样会
2.使用Java内置数组情况，直接对原始数组中的元素进行排序就OK了。不需要讲数组进行复制到别的位置中去

比如下面的解法就是num[i]>2*num[j],
直接在主体函数中进行处理两边的元素情况

 public  int solution_2(int []nums){
        return mergeSort(nums, 0, nums.length-1);
    }
    private int mergeSort(int[] nums, int s, int e){
        if(s>=e) {return 0;}
        int mid = s + (e-s)/2;
        int cnt = mergeSort(nums, s, mid) + mergeSort(nums, mid+1, e);
        //直接把核心函数写在主调用函数中去
        for(int i = s, j = mid+1; i<=mid; i++){
            //为何要转化为2.0的形式，主要是为了以防止溢出
            while(j<=e && nums[i]/2.0 > nums[j]) {j++;}
            cnt += j-(mid+1);
        }
        Arrays.sort(nums, s, e+1);
        return cnt;
    }

复杂度分析

时间复杂度为O(nlog(n)),