剑指51—数组中的逆序对

题目

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。
即输出P%1000000007。
示例：
输入：
1,2,3,4,5,6,7,0
输出：
7

思路

1. 逆序对的存在表明数字没有按照顺序排列，因此进行排序的时候将交换次数累计下来即可得到逆序对的数量。但这要求排序算法是稳定，即不会造成多余的交换。
2. 三种简单算法：冒泡、简单选择、直接插入都是稳定的排序算法，但它们的时间复杂度都是O(n^2)的，如果要求较低可以使用该方法。
3. 高级算法中，常用的只有归并排序是稳定的。

代码

冒泡排序求解代码：

public class Solution {
    public int InversePairs(int[] array){
        if(array==null||array.length==0)
            return 0;
        long cnt = 0;
        for(int i=0;i<array.length-1;i++){
            for(int j=array.length-2;j>=0;j--){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    cnt++;
                }
            }
        }
        return (int)(cnt%1000000007);
    }

    private void swap(int[] array,int i,int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

归并排序求解代码：

public class Solution {
    private long cnt = 0;
    private int[] tmp;
    public int InversePairs(int [] array) {
        tmp = new int[array.length];
        mergeSort(array,0,array.length-1);
        return (int)(cnt%1000000007);
    }

    private void mergeSort(int[] nums,int l,int h){
        if(h==l)
            return;
        int m = (l+h)/2;
        mergeSort(nums, l ,m);
        mergeSort(nums,m+1,h);
        merge(nums,l,m,h);
    }
    private void merge(int[] nums,int l,int m,int h){
        int i = l,j=m+1,k=l;
        while(i<=m||j<=h){
            if(i>m)
                //前半段归并完成，后半段挨个插入，不存在逆序
                tmp[k] = nums[j++];
            else if(j>h)
                //后半段归并完成，前半段挨个插入，也不存在逆序
                tmp[k] = nums[i++];
            else if(nums[i]<=nums[j])
                //前半段数据小，先插入，不存在逆序
                tmp[k] = nums[i++];
            else{
                //后半段数据小，只有这里出现逆序
                tmp[k] = nums[j++];
                this.cnt += m-i+1;
            }
            k++;
        }
        for(k=l;k<=h;k++)
            nums[k] = tmp[k];
    }
}

图的话等熟练了再补啦。