剑指 Offer 51. 数组中的逆序对

目录

题目

思路

题解

复杂度分析

---

题目

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

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

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/solution/shu-zu-zhong-de-ni-xu-dui-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

限制：0 <= 数组长度 <= 50000

思路

逆序：数组前面的元素 > 后面的元素

可利用归并排序的思想，在合并过程中求出逆序对。
merge时恰好就是前面数组元素 > 后面子数组元素才合并，符合逆序的定义。

就是在归并排序的merge的过程中，顺带求了一下逆序对的个数。

只有当两个子数组都还存在元素且第一个子数组的元素arr[i] > arr[j]才可能构成逆序对，且逆序对的个数恰好为第一个数组从i开始到结束的剩余元素个数。

merge操作中设置count计数器，统计逆序对个数。

题解

/**
 * 剑指 Offer 51. 数组中的逆序对
 */
public class Offer51_reversePairs {
    public int reversePairs(int[] nums) {
        return reversePairsInternal(nums, 0, nums.length - 1);
    }

    /**
     * 在nums[l..r]上进行归并排序，返回排序后的逆序对的个数
     */
    private int reversePairsInternal(int[] nums, int l, int r) {
        // 数组为空或者只有一个元素
        if (l >= r) {
            return 0;
        }
        int mid = l + (r - l) / 2;
        // 先求出第一个子数组的逆序对个数
        int leftCount = reversePairsInternal(nums, l, mid);
        // 再求出第二个子数组的逆序对个数
        int rightCount = reversePairsInternal(nums, mid + 1, r);
        if (nums[mid] > nums[mid + 1]) {
            // 左右数组有序后，这两个数组之间还存在逆序，merge过程再求出此时合并过程中的逆序对个数
            return leftCount + rightCount + merge(nums, l, mid, r);
        }
        // nums[mid] < nums[mid + 1]整个数组已经有序，不可能再有逆序对了！
        return leftCount + rightCount;
    }

    /**
     * 合并两个有序的子数组nums[l..mid] nums[mid + 1..r]返回合并后逆序对个数
     */
    private int merge(int[] nums, int l, int mid, int r) {
        // 合并的时候产生的逆序对的个数
        int count = 0;
        int aux[] = new int[r - l + 1];
        for (int i = l; i <= r; i++) {
            aux[i - l] = nums[i];
        }
        int i = l, j = mid + 1;
        for (int k = l; k <= r; k++) {
            if (i > mid) {
                // 第一个数组已经处理完毕，直接拼接第二个数组，此时没有逆序对
                nums[k] = aux[j - l];
                j++;
            } else if (j > r) {
                // 第二个数组已经处理完毕，直接拼接第一个数组，此时没有逆序对
                nums[k] = aux[i - l];
                i++;
            } else if (aux[i - l] <= aux[j - l]) {
                // 拼接第一个数组，此时没有逆序
                nums[k] = aux[i - l];
                i++;
            } else {
                // 此时第一个数组元素 > 第二个数组元素，
                // 从i开始到mid结束的所有元素相较于arr[j]都是逆序对
                // 逆序对的个数恰好为mid - i + 1
                count += mid - i + 1;
                nums[k] = aux[j - l];
                j++;
            }
        }
        return count;
    }
}

复杂度分析

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