牛客刷题之数组中的逆序对

最新推荐文章于 2022-12-13 12:02:24 发布

墨羽lp

最新推荐文章于 2022-12-13 12:02:24 发布

阅读量246

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_40651109/article/details/99705282

版权

数据结构专栏收录该内容

44 篇文章 0 订阅

订阅专栏

该博客介绍了如何求解数组中的逆序对问题，包括两种解题思路：暴力遍历（时间复杂度较高）和利用归并排序思想（效率更高）。重点在于使用归并排序策略，通过递归分解数组并合并，同时计算逆序对数量，以降低算法的时间复杂度。

摘要由CSDN通过智能技术生成

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

解题思路一：

暴力遍历数组，每个数都两两相比，如果前边的数大于后边的数，则逆序对数加1，依次来统计。

public class Solution24 {
    public int InversePairs(int [] array) {
        if(array == null){
            return 0;
        }
        int count = 0;
        for(int i =0;i<array.length;i++){
            for(int j=i+1;j<array.length;j++){
                if(array[i]>array[j]){
                    count += 1;
                }
            }
        }
        return  count%1000000007;
    }

    public static void main(String[] args){
        Solution24 s24 = new Solution24();
        int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,0};
        int result = s24.InversePairs(array);
        System.out.println(result);
    }
}

缺点：算法时间复杂度较高。

思路二：采用归并排序的思想，先把数组递归分解，比如对于长度为4的数组，先把数组分解成两个长度为2的子数组，再把这两个子数组分别拆分成两个长度为1的子数组，接下来，一边合并相邻的子数组，一边统计逆序对的数目。

public class Solution {
    int count = 0;

    public int InversePairs(int[] array) {
        if (array.length <= 0 || array == null) {
            return 0;
        }
        MergeSort(array, 0, array.length - 1);
        return count % 1000000007;
    }

    void MergeSort(int[] array, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            MergeSort(array, left, mid);
            MergeSort(array, mid + 1, right);
            Merge(array, left, mid, right);
        }
    }

    void Merge(int[] array, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = mid;
        int j = right;
        int k = temp.length - 1;
        while (i >= left && j >= mid+1) {
            if (array[i] > array[j]) {
                temp[k--] = array[i--];
                count += j - mid;
                if(count > 1000000007){
                    count %= 1000000007;
                }
            } else {
                temp[k--] = array[j--];
            }
        }

        while (i >= left) {
            temp[k--] = array[i--];
        }
        while (j > mid) {
            temp[k--] = array[j--];
        }

        for (int i1 = 0; i1 < temp.length; i1++) {
            array[left++] = temp[i1];
        }
    }
}