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

1 题目描述

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

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

限制:

0 <= 数组长度 <= 50000

2 解题思路(看解法二)

解法一:归并排序

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

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

在待排序序列长度为1的时候,递归开始回升,因为我们默认长度为1的序列是排好序的。
思路:
那么求逆序对和归并排序又有什么关系呢?关键就在于归并当中并的过程。我们通过一个实例来看看。假设我们有两个已排序的序列等待合并,分别是 L = { 8 , 12 , 16 , 22 , 100 } L=\{8,12,16,22,100\} L={8,12,16,22,100} R = { 9 , 26 , 55 , 64 , 91 } R=\{9,26,55,64,91\} 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);
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值