剑指offer-数组

剑指offer练习题

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
对于%50%的数据,size\leq 10^4size≤10**4
对于75%的数据,size\leq 10^5size≤10 **5
对于100%的数据,size\leq 2*10^5size≤2∗10 **5（ **表示2次方）
输入：[1,2,3,4,5,6,7,0]
返回值：7

思路一：双重循环，外循环和内循环比较，是否外循环大于内循环，这样的时间复杂度为O(n**2),会超时。

思路二：采用归并排序算法的思想，将数组分而治之。治的过程中很容易发现逆序对。

即将数组的每一个元素当成一个独立的数组，相邻两个数组排序，最后成一个有序的数组。我们可以发现每一次比如[4,8]和[5,7]排序，4小于5，将4放入新的数组中，5小于8，这时产生了逆序，程序中left为左边数组的起点，mid为左边数组的终点，mid+1为右边数组的起点，right为右边数组的终点，当产生逆序对时，个数时mid-i+1.通过归并排序的思想降低时间复杂度。

import java.util.Arrays;

public class Solution3 {
    public static void main(String[] args) {
        int[] array={9,8,7,6,5,4,3,2,1};
        System.out.println(sort(array));
    }
    public static int sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        return sort(arr,0,arr.length-1,temp);
    }
    public static int sort(int[] arr ,int left,int right,int[] temp){
       if(left<right){
           int mid=(left+right)/2;
           sort(arr,left,mid,temp);
           sort(arr,mid+1,right,temp);
           return merge(arr,left,mid,right,temp);
       }
       return 0;
    }
    public static int merge(int[] arr, int left, int mid, int right, int[] tempt){
        //mid是左边数组的最右边，right是右边数组的最右边
        int i=left;//i和j分别是两个数组的开始点
        int j=mid+1;
        int t=0;//t是temp数组的起点，tempt是用来保存有序数组的
        int count=0;
        while(i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                tempt[t++]=arr[i++];
            }
            else{
                tempt[t++]=arr[j++];
                count+=mid-i+1;
                count%=1000000007;
            }
        }
//        System.out.ouprintln(count);
        while (i<=mid){
            tempt[t++]=arr[i++];
        }
        while (j<=right){
            tempt[t++]=arr[j++];
        }
        t=0;
        while (left<=right){
            arr[left++]=tempt[t++];
        }
        return count;
    }
}

归并排序是一个稳定的排序算法，时间复杂度O(nlogn)，Java中的sort排序就是使用优化的归并排序算法。