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

题目

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例 1:

输入: [7,5,6,4]
输出: 5

限制：

0 <= 数组长度 <= 50000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof

一、解题思路（归并排序）

在此题目中，如果使用暴力法遍历统计逆序对数量，时间复杂度为O(n²)，本题数组长度：0 <= 数组长度 <= 50000，铁定超时了（因为我试过）。

归并排序和逆序对是息息相关的，归并排序是一种分而治之的算法思想

• 分： 不断从中间点将数组一分为二，将数组的排序转为子数组的排序
• 治： 划分到子数组长度为 1 时，向上合并，直至合并至完整数组；
  （如上图所示）

我在归并排序代码中打印了排序的过程如下：

--------------------
排序前：[7, 3]
排序后：[3, 7]
现数组：[3, 7, 5, 1, 6, 4, 8, 2]
--------------------
排序前：[5, 1]
排序后：[1, 5]
现数组：[3, 7, 1, 5, 6, 4, 8, 2]
--------------------
排序前：[3, 7, 1, 5]
排序后：[1, 3, 5, 7]
现数组：[1, 3, 5, 7, 6, 4, 8, 2]
--------------------
排序前：[6, 4]
排序后：[4, 6]
现数组：[1, 3, 5, 7, 4, 6, 8, 2]
--------------------
排序前：[8, 2]
排序后：[2, 8]
现数组：[1, 3, 5, 7, 4, 6, 2, 8]
--------------------
排序前：[4, 6, 2, 8]
排序后：[2, 4, 6, 8]
现数组：[1, 3, 5, 7, 2, 4, 6, 8]
--------------------
排序前：[1, 3, 5, 7, 2, 4, 6, 8]
排序后：[1, 2, 3, 4, 5, 6, 7, 8]
现数组：[1, 2, 3, 4, 5, 6, 7, 8]

我们截取这一段看看图解如下：

排序前：[4, 6, 2, 8]
排序后：[2, 4, 6, 8]
现数组：[1, 3, 5, 7, 2, 4, 6, 8]

在这个图中：
left是4的下标，right是8的下标，所以mid就是6的下标。
初始化 i 等于 left，j 等于 mid + 1。
当 nums[i]<=nums[j] 时 , 把 nums[i] 添加到辅助数组中，并i++；
当 nums[i]>nums[j] 时，把nums[j] 添加到辅助数组中，并j++。而因为我们要计算逆序对，我们可以在这个基础上 res+=mid-i+1 ，从而计算逆序对的值。

为什么是 res+=mid-i+1 呢？
这是因为 [left,mid] 与 [mid+1,right] 都是有序序列，当 [left,mid] 序列中有nums[i]>nums[j] ，则有 [i,mid] 中所有的数都大于nums[j]。

二、代码

归并操作的工作原理如下：

• 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
• 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
• 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空
  间，并移动指针到下一位置
• 重复步骤3直到某一指针超出序列尾
• 第四步：将另一序列剩下的所有元素直接复制到合并序列尾
• 第五步：覆盖

	//易理解版本  利用归并排序特性，在此基础上，
    //当nums[temp1]>nums[temp2],res+=mid-temp1+1
class Solution {
    int count;
    public int reversePairs(int[] nums){
        this.count =0;
        merge(nums,0,nums.length-1);
        return count;
    }
    //分
    public void merge(int[] nums,int left,int right){
        if(left<right){ 
            int mid = left+((right-left)>>1);
            merge(nums,left,mid);
            merge(nums,mid+1,right);
            mergeSort(nums,left,mid,right);
        }
    }
    public void mergeSort(int[] nums,int left,int mid,int right){
    	//1
        int[] temparr = new int[right-left+1];
        int index = 0;
        //2
        int temp1=left,temp2 =mid+1;
		//3
        while(temp1<=mid&&temp2<=right){
            if(nums[temp1]<=nums[temp2]){
                temparr[index++]=nums[temp1++];
            }else{
                count+=mid-temp1+1;
                temparr[index++]=nums[temp2++];
            }
        }
        //4
        while(temp1<=mid){
            temparr[index++] = nums[temp1++];
        }
        while(temp2<=right){
            temparr[index++] = nums[temp2++];
        }
        
        //5 把新数组temparr[]覆盖nums[left,right]
        for(int i =0;i<temparr.length;i++){
            nums[left+i]=temparr[i];
        }
    }
}

思路一样，代码精简点：

class Solution {
    int[] nums, tmp;
    public int reversePairs(int[] nums) {
        this.nums = nums;
        tmp = new int[nums.length];
        return mergeSort(0, nums.length - 1);
    }
    private int mergeSort(int l, int r) {
        // 终止条件
        if (l >= r) return 0;
        // 递归划分
        int m = (l + r) / 2;
        int res = mergeSort(l, m) + mergeSort(m + 1, r);
        // 合并阶段
        int i = l, j = m + 1;
        for (int k = l; k <= r; k++)
            tmp[k] = nums[k];
        for (int k = l; k <= r; k++) {
            if (i == m + 1)
                nums[k] = tmp[j++];
            else if (j == r + 1 || tmp[i] <= tmp[j])
                nums[k] = tmp[i++];
            else {
                nums[k] = tmp[j++];
                res += m - i + 1; // 统计逆序对
            }
        }
        return res;
    }
}

解析参考Krahets
https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/solution/jian-zhi-offer-51-shu-zu-zhong-de-ni-xu-pvn2h/

侵删