数组中的逆序对

最新推荐文章于 2021-06-08 15:39:37 发布

原创最新推荐文章于 2021-06-08 15:39:37 发布 · 229 阅读

0 ·

CC 4.0 BY-SA版权

剑指offer 专栏收录该内容

61 篇文章

订阅专栏

本文介绍了一种利用归并排序算法计算数组中逆序对数量的方法。通过递归地将数组分为两半，分别计算左右两边的逆序对，然后在合并过程中计算跨两边的逆序对，实现了O(nlogn)的时间复杂度。

1.题目

在这里插入图片描述

2.解法

使用的是归并排序

public class Solution {
    private int count = 0;
    private int mod = (int)1e9 + 7;
    private int[] copy = new int[200000];
    
    public int InversePairs(int [] array) {
        int len = array.length;
        if(array == null || len == 0){
            return 0;
        }
        
        MergeSort(array, 0, len-1);
        return count;
    }
    
    public void MergeSort(int[] array, int start, int end){
        if(start < end){
            int mid = start + (end - start)/2;
            
            // 左右两部分递归
            MergeSort(array, start, mid);
            MergeSort(array, mid+1, end);
            Merge(array, start, mid, end);
        }
    }
    
    public void Merge(int[] array, int start, int mid, int end){
        
        // 统计逆序值，并排序
        // i是前半段最后一个值的下标
        int i = mid;
        // j是后半段最后一个值的下标
        int j = end;
        
        // copy数组最后一个位置
        int index = end;
        
        while(i >= start && j >= mid + 1) {
            // 逆序
            if (array[i] > array[j]) {
                copy[index--] = array[i--];
                count = (count + j - mid) % mod;
            } else {
                copy[index--] = array[j--];
            }
        }
            
        while(i >= start){
            copy[index--] = array[i--];
        }
        
         while(j >= mid + 1){
            copy[index--] = array[j--];
        }
            
        for (int k = start; k <= end ; k++) {
            array[k] = copy[k];
        }
     }
}

时间复杂度O(nlogn), 空间复杂度为O(n),属于空间换时间做法
使用递归很容易超时,所以提前预设copy数组还有已知变量可以节省时间