主要是归并排序中的关键思想情况
如何设计归并排序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 这个就是统计的时候的部分
- 最后关于如何将中间数组的结果复制到 原来数组中，让原来数组中的元素情况按照有序的情况进行排序
最后是将中间数组的长度为原始数组的长度一样的长度，
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.使用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)),