数组中的逆序对【Java】【剑指Offer】

题目：

数组中的逆序对

描述：

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

输入描述

题目保证输入的数组中没有的相同的数字

数据范围：

    对于%50的数据,size<=10^4

    对于%75的数据,size<=10^5

    对于%100的数据,size<=2*10^5 

输入：

{1,2,3,4,5,6,7,0}

输出：

7

思路：

方法一：

暴力破解。

方法二(看到这个题目的时候，临时想的，时间复杂度和空间复杂度都比较大，只是作为拓展所以写的比较详细)：

再次说明：虽然时原创，但是这就是个垃圾算法，看看就行了。

1. 复制一个数组copy，并且排序
2. 创建一个Map<Integer,Integer>记录<值,位置>
3. 遍历array2，最小的位置之前的一定全都是大于这个数所以为k(位置)，最大的之前的一定全都小于这个数所以为0
4. 对于其他的数：
    1. 前面是否有比他小的，有几个就减掉几。

对于4.1:
    创建一个链表linkList，用于存放第三步遍历时，已经遍历过的数的位置，并排序(插入排序)
    这个时候，就可以很轻易的拿到前面有几个比他小的了。

方法三：

归并思想。最优。

代码：

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

public class Solution {
    // 方法一
    public int InversePairs1(int [] array) {
        if(array == null || array.length <= 0){
            return 0;
        }
        int size = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i; j < array.length; j++) {
                if(array[i] > array[j]){
                    size++;
                }
            }
        }
        return size % 1000000007;
    }
    // 方法二
    public int InversePairs2(int [] array) {
        if(array == null || array.length <= 0){
            return 0;
        }
        int size = 0;
        // 按照顺序记录位置，最终的位置是经过排序的，使用链表的有点，插入方便
        LinkedList<Integer> linkedList = new LinkedList<>();
        int[] copy = Arrays.copyOf(array, array.length);
        Arrays.sort(copy);
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < array.length; i++) {
            // 记录值对应的位置
            map.put(array[i],i);
        }
        // 排序位置，并且记录逆序列的个数
        for (int i = 0; i < copy.length; i++) {
            int number = copy[i];
            Integer place = map.get(number);
            if(i == 0){
                // 第一个没有对照物，直接加入
                size += place;
                linkedList.add(place);
            }else if(i == copy.length - 1){
                // 最后一个直接加入
                linkedList.add(place);
            }else {
                int j = 0;
                for (;j < linkedList.size(); j++) {
                    // 判断当前数是否比链表中的最后一个的值大，大，则位置插入到第一个比他小的位置上。
                    if(linkedList.get(j) > place){
                        linkedList.add(j,place);
                        break;
                    }
                }
                if(j == linkedList.size()){
                    linkedList.add(place);
                }
                size = size + place - j;
            }
        }
        return size % 1000000007;
    }
    // 方法三
    public int InversePairs3(int [] array) {
        if(array.length != 0){
            divide(array,0,array.length-1);
        }
        return cnt;
    }
 
    //归并排序的分治---分
    private void divide(int[] arr,int start,int end){
        //递归的终止条件
        if(start >= end)
            return;
        //计算中间值，注意溢出
        int mid = start + (end - start)/2;
 
        //递归分
        divide(arr,start,mid);
        divide(arr,mid+1,end);
 
        //治
        merge(arr,start,mid,end);
    }
 
    private void merge(int[] arr,int start,int mid,int end){
        int[] temp = new int[end-start+1];
 
        //存一下变量
        int i=start,j=mid+1,k=0;
        //下面就开始两两进行比较，若前面的数大于后面的数，就构成逆序对
        while(i<=mid && j<=end){
            //若前面小于后面，直接存进去，并且移动前面数所在的数组的指针即可
            if(arr[i] <= arr[j]){
                temp[k++] = arr[i++];
            }else{
                temp[k++] = arr[j++];
                //a[i]>a[j]了，那么这一次，从a[i]开始到a[mid]必定都是大于这个a[j]的，因为此时分治的两边已经是各自有序了
                cnt = (cnt+mid-i+1)%1000000007;
            }
        }
        //各自还有剩余的没比完，直接赋值即可
        while(i<=mid)
            temp[k++] = arr[i++];
        while(j<=end)
            temp[k++] = arr[j++];
        //覆盖原数组
        for (k = 0; k < temp.length; k++)
            arr[start + k] = temp[k];
    }
}