【leetcode】数组中的逆序对-归并算法总结

最新推荐文章于 2024-10-20 09:49:14 发布

原创最新推荐文章于 2024-10-20 09:49:14 发布 · 405 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

个人学习同时被 3 个专栏收录

18 篇文章

订阅专栏

学习整理总结

16 篇文章

订阅专栏

LeetCode

2 篇文章

订阅专栏

本文总结了如何使用归并排序解决LeetCode中的逆序对问题。通过图解和步骤分析，详细解释了如何利用归并排序过程中数组的有序性计算逆序对，并介绍了算法的时间和空间复杂度。

数组中的逆序对

记录下这个解题的思路以及归并排序的意义

思路一：暴力，双重for循环

int reversePairs(vector<int>& nums) {
    int count = 0;
    int len = nums.size();
    for (int i = 0; i < len - 1; ++i) {
        for (int j = i + 1; j < len; ++j) {
            if (nums[i] > nums[j]) {
                count++;
            }
        }
        return count;
    }
}

思路二：归并排序

看到逆序对的时候，没法下手的感觉，看了大佬们的题解，记录下归并算法的用途。

计算逆序数就发生在归并排序的过程中，利用排序后数组的有序性。

图解如下：

1 先将排序后的数组一分为二，变成两个有序数组

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45qjcfhv-1587699782150)(C:\Users\Wiley\AppData\Roaming\Typora\typora-user-images\image-20200424112510649.png)]$

2 遍历比较两个小数组的各个元素，从图中看出，左边数组第一个元素是2，右边元素第一个数组是1，1与2相比较发现左边的有序数组所有元素肯定都是元素1的逆序数，这就利用了归并数组的部分有序性来计算逆序数。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vx1tpYiY-1587699665005)(C:\Users\Wiley\AppData\Roaming\Typora\typora-user-images\image-20200424112915178.png)]$

3 遍历所有元素

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KvTrJ1l2-1587699665020)(C:\Users\Wiley\AppData\Roaming\Typora\typora-user-images\image-20200424113511091.png)]$

注意：能够使用本方法的原因是两个子数组分别有序。这个数组的分治法，分完之后治的过程，不是分的过程。

关键步骤：

合并两个有序数组过程中，利用数组的部分有序性，一下子计算出一个数之前或者之后元素的逆序的个数；
主要是在合并过程中计算逆序对的个数。

逆序对的个数来自三个部分：

左边的逆序对
右边的逆序对
合并整个数组的逆袭对

代码：

class Solution {
    vector<int> res;
public:
    int reversePairs(vector<int>& nums) {
        //return mergesort(nums, 0, nums.size() - 1);
        res.resize(nums.size(), 0);
        return merge_sort(nums, 0, nums.size() - 1);
    }

    int merge_sort(vector<int>& nums, int left, int right) {
        if (left >= right) return 0;
        int mid = left + (right - left) / 2;
        int count = merge_sort(nums, left, mid) + merge_sort(nums, mid + 1, right);
        int i = left, j = mid + 1, k = left;
        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                res[k++] = nums[i++];
            }
            else {
                count += mid - i + 1;
                res[k++] = nums[j++];
            }
        }
        while (i <= mid) res[k++] = nums[i++];
        while (j <= right) res[k++] = nums[j++];
        for (int i = left; i <= right; ++i) {
            nums[i] = res[i];
        }
        return count;
    }

    // int mergesort(vector<int>& nums, int left, int right) {
    //     if (left >= right) return 0;
    //     int mid = left + (right - left) >> 1;
    //     return mergesort(nums, left, mid) + mergesort(nums, mid + 1, right) + merge(nums, left, mid, right);
    // }

    // int merge(vector<int>& nums, int left, int mid, int right) {
    //     int i = left;
    //     int j = mid + 1;
    //     int k = 0;
    //     int count = 0;
    //     vector<int> res(right - left + 1, 0);
    //     while (i <= mid && j <= right) {
    //         if (nums[i] > nums[j]) count += mid - i + 1;
    //         res[k++] = nums[i] <= nums[j] ? nums[i++] : nums[j++];
    //     }
    //     while (i <= mid) res[k++] = nums[i++];
    //     while (j <= right) res[k++] = nums[j++];
    //     for (int i = 0; i < res.size(); ++i) {
    //         nums[left + i] = res[i];
    //     }
    //     return count;
    // }
};

复杂度分析

记序列长度为 n。

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