题目描述
思路解析
其实可以直接用暴力循环的方式来做这道题，但这么做时间复杂度就会变成O(N²)，没技术含量不说，如果笔试的时候写这种算法那肯定是过不了，因此我们可以用换一种思路。
- 换个角度想，逆序对完全可以这么想：
- 假设数组int[] arr={7,5,6,4}：
- 从7开始依次向后找，右边有3个比7小的数，逆序对就为3；
- 再从5开始，右边有1个比5小的数，逆序对就为1；
- 再从6开始，右边有1个比6小的数，逆序对就为1；
- 最后到4，4右边没有数，故逆序对为0；
- 因此数组的逆序对为3+1+1=5组。
这时有人会问，那你这么找不还是要遍历吗？这跟暴力循环有啥区别？但是，如果这个数组是逆序呢？那岂不是可以直接用下标来计算逆序对？
- 假设数组：int[] arr={7,5,4,3,1};
- 从7开始，逆序对就为(4-1+1)=4(4为7右边的元素个数，计算方法为(1的索引-5的索引+1));
- 再从5开始，逆序对为(4-2+1)=3;
- 再从4开始，逆序对为(4-3+1)=2;
- 再从3开始，逆序对为(4-4+1)=1;
- 最后从1开始，右边无元素，故逆序对为0；
- 因此数组的逆序对为4+3+2+1+0=10组。
那么有什么算法可以在实现这些方法的同时，又保证时间复杂度小于O(N²)呢？
答案是归并排序。
代码解析
1、分组
//归并排序--分组
public static int process(int[] arr, int left, int right) {
if (left == right) {
// left==right，说明只剩一个数，则不存在逆序对，所以返回0
return 0;
}
int mid = left + ((right - left) >> 1);//中间值的坐标
return process(arr, left, mid)//分组
+ process(arr, mid + 1, right)//分组
+ merge(arr, left, mid, right);//归并
}
2、比较
(1)、数组中只有一个元素
if (left == right) {
// left==right，说明只剩一个数，则不存在小和，所以返回0
return 0;
}
(2)、数组中有多个元素
int p = 0;//记录临时数组tmp的小标
int p1 = left;//记录左组第一个元素的下标
int p2 = mid + 1;//记录右组第一个元素的下标
int RP = 0;//记录当前数组的逆序对对数
//比较
while (p1 <= mid && p2 <= right) {
RP += arr[p1] > arr[p2] ? (right - p2 + 1) : 0;
//通过下标来计算有多少个逆序对
}
计算逆序对的步骤
RP += arr[p1] < arr[p2] ? (right - p2 + 1) * arr[p1] : 0;
- 从左组的第一个元素开始(
arr[p1])，跟右组的第一个元素(arr[p2])进行比较：- 如果
arr[p1]小于arr[p2]，那就说明从arr[p2]开始(包括arr[p2])，右组的所有元素都大于arr[p1]，那么此时的逆序对就是右组中大于arr[p1]的个数(right - p2 + 1)；- 如果
arr[p1]大于或等于arr[p2]，那就让右组的第二个元素跟arr[p1]进行比较，依次类推，当arr[p1]跟右组中的所有元素比较完后，再让左组的第二个元素跟右组的第一个元素比较，以此类推。
3、排序+归并
和归并排序的方法一样，如下所示：
int[] tmp = new int[(right - left) + 1];
//临时数组，用来存储已经排好序的元素，并将所有元素拷贝到当前数组中
while (p1 <= mid && p2 <= right) {
RP += arr[p1] > arr[p2] ? (right - p2 + 1) : 0;
//通过下标来计算有多少个逆序对
tmp[p++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
//降序排列
//只有当arr[p1]严格大于arr[p2]时，才会将arr[p1++]存入tmp中
}
//将左组中的剩余元素存入tmp
while (p1 <= mid) {
tmp[p++] = arr[p1++];
}
//将右组中的剩余元素存入tmp
while (p2 <= right) {
tmp[p++] = arr[p2++];
}
//将tmp的内容拷贝到原数组中
for (int i = 0; i < tmp.length; i++) {
arr[i+left]=tmp[i];
}
举例
如果按照归并排序的方式递归分组，分完后就会是这样的情况：
从最底层开始：
对于数组⑧，2的右边没有数，因此数组⑧的逆序对为0(只有一个数时，返回0)；
对于数组⑨，5的右边没有数，因此数组⑨的逆序对为0(只有一个数时，返回0)；
然后将数组⑧和⑨进行排序，因为这两个数组都只有一个元素，故排序后不变，再将数组⑧和⑨进行归并后就是数组③的样子：
接着对数组④求逆序对，左组中第一个元素为2，右组中第一个元素为5，2小于5，因此数组④的逆序对为0。自此，数组④的逆序对就已经求完了，接下来将数组④进行排序即可，排完后如下图：
因为第⑤组只有一个元素，因此其逆序对总数为0，而且也无需排序，然后将第④组和第⑤组合并：
接着按照计算逆序对的步骤依次进行，最后第②组的逆序对为：0+0+0+0+1×1+0=1(④⑤⑧⑨组的小和再加②组本身的逆序对)
左半边排完了，右半边的步骤与其一样，因此右半边求完逆序对后的状态如下：
其逆序对为：0+0+0=0(左子组加右子组的逆序对，最后加本身的逆序对)
接着将②组和③组进行归并：
依旧根据计算小和的步骤，求得其逆序对为1+0+1×2+1×1+1×2=6
完整代码：
package 苟熊岭熊哒;
//数组中的逆序对
public class ReversePairs {
//归并排序求逆序对
public static int reversePairs(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
int left = 0;
int right = arr.length - 1;
return process(arr, left, right);
}
//归并排序--分组
public static int process(int[] arr, int left, int right) {
if (left == right) {
return 0;
}
int mid = left + ((right - left) >> 1);
return process(arr, left, mid)
+ process(arr, mid+1, right)
+ merge(arr, left, mid, right);
}
//归并排序--归并
public static int merge(int[] arr, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int p = 0;
int p1 = left;
int p2 = mid + 1;
int RP = 0;// 记录逆序对的个数
while (p1 <= mid && p2 <= right) {
RP += arr[p1] > arr[p2] ? (right - p2 + 1) : 0;
//通过下标来计算有多少个逆序对
tmp[p++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
//降序排列
//只有当arr[p1]严格大于arr[p2]时，才会将arr[p1++]存入tmp中
}
//将左组中的剩余元素存入tmp
while (p1 <= mid) {
tmp[p++] = arr[p1++];
}
//将右组中的剩余元素存入tmp
while (p2 <= right) {
tmp[p++] = arr[p2++];
}
//将tmp的内容拷贝到原数组中
for (int i = 0; i < tmp.length; i++) {
arr[i + left] = tmp[i];
}
return RP;//返回逆序对的个数
}
public static void main(String[] args) {
int[] arr= {2,5,4,1,3};
int result=reversePairs(arr);
System.out.println("逆序对对数为："+result);
}
}
输出结果：
力扣通过代码
class Solution {
public static int process(int[] nums, int left, int right) {
if (left == right) {
return 0;
}
int mid = left + ((right - left) >> 1);
return process(nums, left, mid)
+ process(nums, mid+1, right)
+ merge(nums, left, mid, right);
}
public static int merge(int[] nums, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int p = 0;
int p1 = left;
int p2 = mid + 1;
int RP = 0;// 记录逆序对的个数
while (p1 <= mid && p2 <= right) {
RP += nums[p1] > nums[p2] ? (right - p2 + 1) : 0;
//通过下标来计算有多少个逆序对
tmp[p++] = nums[p1] > nums[p2] ? nums[p1++] : nums[p2++];
//降序排列
//只有当nums[p1]严格大于nums[p2]时，才会将nums[p1++]存入tmp中
}
while (p1 <= mid) {
tmp[p++] = nums[p1++];
}
while (p2 <= right) {
tmp[p++] = nums[p2++];
}
for (int i = 0; i < tmp.length; i++) {
nums[i + left] = tmp[i];
}
return RP;
}
public int reversePairs(int[] nums) {
if (nums == null || nums.length < 2) {
return 0;
}
int left = 0;
int right = nums.length - 1;
return process(nums, left, right);
}
}
提交记录：
对数器测试完整代码
package 苟熊岭熊哒;
//数组中的逆序对
public class ReversePairs {
//归并排序求逆序对
public static int reversePairs(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
int left = 0;
int right = arr.length - 1;
return process(arr, left, right);
}
//归并排序--分组
public static int process(int[] arr, int left, int right) {
if (left == right) {
return 0;
}
int mid = left + ((right - left) >> 1);
return process(arr, left, mid)
+ process(arr, mid+1, right)
+ merge(arr, left, mid, right);
}
//归并排序--归并
public static int merge(int[] arr, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int p = 0;
int p1 = left;
int p2 = mid + 1;
int RP = 0;// 记录逆序对的个数
while (p1 <= mid && p2 <= right) {
RP += arr[p1] > arr[p2] ? (right - p2 + 1) : 0;
//通过下标来计算有多少个逆序对
tmp[p++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
//降序排列
//只有当arr[p1]严格大于arr[p2]时，才会将arr[p1++]存入tmp中
}
while (p1 <= mid) {
tmp[p++] = arr[p1++];
}
while (p2 <= right) {
tmp[p++] = arr[p2++];
}
for (int i = 0; i < tmp.length; i++) {
arr[i + left] = tmp[i];
}
return RP;
}
//for test
// 暴力循环求逆序对
public static int comparator(int[] arr) {
int sum = 0;
for (int i = arr.length - 1; i >= 0; i--) {
for (int j = i - 1; j >= 0; j--) {
sum += arr[j] > arr[i] ? 1 : 0;
}
}
return sum;
}
// 生成一个随机数组
public static int[] generateRandomArray(int maxSize, int maxValue) {
// Math.random() -> 随机在[0,1)范围内返回一个double类型的数(等概率)
// Math.random()*A -> 随机在[0,A)范围内返回一个double类型的数(等概率)
// (int)(Math.random()*A) -> 随机在[0,A-1]范围内返回一个int类型的数(等概率)
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1) * Math.random());
}
return arr;
}
// 拷贝数组
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i];
}
return res;
}
// 判断arr1和arr2中的每个值是否相等
public static boolean isEqual(int result1, int result2) {
return result1==result2;
}
// 打印数组
public static void printArray(int result) {
System.out.println(result);
}
public static void main(String[] args) {
//对数器测试
int testTime = 500000;// 测试次数，50万次
int maxSize = 100;// 数组的规模不大于100
int maxValue = 100;// 数组中每个值的范围，-100~+100
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
// 创建一个数组，长度随机，值也随机
int[] arr2 = copyArray(arr1);
// 拷贝arr1中的值和长度
int result1= reversePairs(arr1);//归并排序求小和
int result2= comparator(arr2);//暴力方法求小和
//比较result1和result2的结果
if (isEqual(result1, result2) == false) {
// 若值不一样，则该次测试失败
succeed = false;
printArray(result1);// 打印result1
printArray(result2);// 打印result2
break;// 跳出循环
}
}
System.out.println(succeed ? "完全正确 !" : "存在错误 !");
}
}
输出结果：
这道题的介绍到这里就结束了，如果你觉得本篇文章对你多少有些帮助，可以点个赞或者收藏一波支持一下哦，欢迎各位大佬批评指正，咱们下次再见！
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
