【排序】51题-数组中的逆序对

最新推荐文章于 2024-09-12 19:02:20 发布

RB_VER

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量99

点赞数

分类专栏：剑指Offer 文章标签：算法数据结构

原文链接：https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/solution/shu-zu-zhong-de-ni-xu-dui-by-leetcode-solution/

版权

剑指Offer 专栏收录该内容

76 篇文章 1 订阅

订阅专栏

1 题目描述

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

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

限制：

0 <= 数组长度 <= 50000

2 解题思路（看解法二）

解法一：归并排序

预备知识：
归并排序是分治思想的典型应用，它包含这样三个步骤：

分解：待排序的区间为[l,r]，令 $=\lfloor{ {l+r} \over {2}} \rfloor$ ，我们把[l,r]分成[l,m]和[m+1,r]。
解决：使用归并排序递归地排序两个子序列。
合并：把两个已经排好序的子序列[l,m]和[m+1,r]合并起来。

在待排序序列长度为1的时候，递归开始回升，因为我们默认长度为1的序列是排好序的。
思路：
那么求逆序对和归并排序又有什么关系呢？关键就在于归并当中并的过程。我们通过一个实例来看看。假设我们有两个已排序的序列等待合并，分别是 $L=\{8,12,16,22,100\}$ 和 $R=\{9,26,55,64,91\}$ 。一开始我们用指针lPtr=0指向L的首部，rPtr=0指向R的头部。记已经合并好的部分为M。

L = [8, 12, 16, 22, 100]   R = [9, 26, 55, 64, 91]  M = []
     |                          |
   lPtr                       rPtr

我们发现lPtr指向的元素小于rPtr指向的元素，于是把lPtr指向的元素放入答案，并把lPtr后移一位。

L = [8, 12, 16, 22, 100]   R = [9, 26, 55, 64, 91]  M = [8]
        |                       |
      lPtr                     rPtr

这个时候我们把左边的8加入答案，我们发现右边没有数比8小，所以8对逆序对总数的贡献为0。接着我们继续合并，把9加入了答案，此时lPtr指向12，rPtr指向26。

L = [8, 12, 16, 22, 100]   R = [9, 26, 55, 64, 91]  M = [8, 9]
        |                          |
       lPtr                       rPtr

此时lPtr比rPtr小，把 lPtr 对应的数加入答案，并考虑它对逆序对总数的贡献为 rPtr 相对 R 首位置的偏移 1（即右边只有一个数比 12 小，所以只有它和 12 构成逆序对），以此类推。

我们发现用这种「算贡献」的思想在合并的过程中计算逆序对的数量的时候，只在 lPtr 右移的时候计算，是基于这样的事实：当前 lPtr 指向的数字比 rPtr 小，但是比 R 中 [0 … rPtr - 1] 的其他数字大，[0 … rPtr - 1] 的其他数字本应当排在 lPtr 对应数字的左边，但是它排在了右边，所以这里就贡献了 rPtr 个逆序对。

class Solution {
    public int reversePairs(int[] nums) {
        int len = nums.length;

        if (len < 2) {
            return 0;
        }

        int[] copy = new int[len];
        for (int i = 0; i < len; i++) {
            copy[i] = nums[i];
        }

        int[] temp = new int[len];
        return reversePairs(copy, 0, len - 1, temp);
    }

    /**
     * nums[left..right] 计算逆序对个数并且排序
     */
    private int reversePairs(int[] nums, int left, int right, int[] temp) {
        if (left == right) {
            return 0;
        }

        int mid = left + (right - left) / 2;
        int leftPairs = reversePairs(nums, left, mid, temp);
        int rightPairs = reversePairs(nums, mid + 1, right, temp);

        if (nums[mid] <= nums[mid + 1]) {
            return leftPairs + rightPairs;
        }

        int crossPairs = mergeAndCount(nums, left, mid, right, temp);
        return leftPairs + rightPairs + crossPairs;
    }

    /**
     * nums[left..mid] 有序，nums[mid + 1..right] 有序
     */
    private int mergeAndCount(int[] nums, int left, int mid, int right, int[] temp) {
        for (int i = left; i <= right; i++) {
            temp[i] = nums[i];
        }

        int i = left;
        int j = mid + 1;

        int count = 0;
        for (int k = left; k <= right; k++) {

            if (i == mid + 1) {
                nums[k] = temp[j];
                j++;
            } else if (j == right + 1) {
                nums[k] = temp[i];
                i++;

                count += (right - mid);
            } else if (temp[i] <= temp[j]) {
                nums[k] = temp[i];
                i++;

                count += (j - mid - 1);
            } else {
                nums[k] = temp[j];
                j++;
            }
        }
        return count;
    }

}

复杂度分析：
记序列长度为 n。

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

解法二：归并排序

归并过程中是怎么计算逆序对个数的。见下图
在这里插入图片描述
我们来拆解下上图，我们此时 temp1 指向元素为 6，temp2 指向元素为 2, nums[temp1] > temp[temp2]，则此时我们需要将 temp2 指向的元素存入临时数组中，又因为每个小集合中的元素都是有序的，所以 temp1 后面的元素也一定大于 2，那么我们就可以根据 temp1 的索引得出逆序对中包含 2 的逆序对个数，则是 mid - temp1 + 1。

代码：

class Solution {
    private int count;
    public int reversePairs(int[] nums) {
        count = 0;
        merge(nums,0,nums.length-1);
        return count;
    }
    private void merge(int[] nums, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            merge(nums,left,mid);
            merge(nums,mid+1,right);
            mergeSort(nums,left,mid,right);
        }
    }
    private void mergeSort(int[] nums, int left, int mid, int right) {
        int[] temparr = new int[right-left+1];
        int index = 0;
        int temp1 = left;
        int temp2 = mid + 1;
        while (temp1 <= mid && temp2 <= right) {
            if (nums[temp1] <= nums[temp2]) temparr[index++] = nums[temp1++];
            else {
                count += mid - temp1 + 1;
                temparr[index++] = nums[temp2++];
            }
        }
        if (temp1 <= mid) System.arraycopy(nums,temp1,temparr,index,mid-temp1+1);
        if (temp2 <= right) System.arraycopy(nums,temp2,temparr,index,right-temp2+1);
        System.arraycopy(temparr,0,nums,left,right-left+1);
    }
}