【剑指offer】数组中的逆序对

一、题目描述

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

• 输入描述

题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5

二、思路分析及代码实现

注意事项：
由于数组中元素数量的增加，题目中涉及到的逆序对可能会超出int的取值，因此在计算过程中就要及时的进行count%1000000007操作，而不是等到最后统一进行操作。
方法一：暴力法

两轮for循环嵌套，顺序扫描整个数组，每扫描到一个数字，逐个比较当前数字与后面数字的大小关系，如果后面的数字比他小，就组成一个逆序对。
时间复杂度： O(n^2） 超时
空间复杂度：O（1）

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

方法二：剑指offer 归并排序

先把数组划分成子数组，统计出子数组内部的逆序对的数目，然后在统计出两个相邻子数组之间的逆序对的数目。在统计逆序对数目的过程中，还需要对数组进行排序。

• 归并排序算法

  public void mergeSortCore(int[] arr, int start, int end){}
    if(start>=end){
      return ;
    }
    int mid=(end+start)/2;
    mergeSortCore(arr,start,mid);
    mergeSortCore(arr,mid+1,end);
    merge(arr,start,mid,end);
  }
  public void merge(int[] arr, int start, int mid, int end){
    int[] temp=new int[end-start+1]; //辅助数组
    int i=0,p1=start,p2=mid+1;
    //有序的辅助数组
    while(p1<=mid&&p2<=end){  
      if(arr[p1]<=arr[p2]){
        temp[i]=arr[p1];
        i++;
        p1++;
      }else {
        temp[i]=arr[p2];
        i++;
        p2++;
      }
    }
    while(p1<=mid){
      temp[i++]=arr[p1++];
    }
    while(p2<=end){
      temp[i++]=arr[p2++];
    }
    for(int i=0;i<temp.length;i++){
      arr[start+i]=temp[i];
    }
  }

• 求逆序对从尾指针合并

public class Solution {
  int count=0;
  public int InversePairs(int [] array) {
    //使用归并排序思想来写
    mergeSortCore(array,0,array.length-1);
    count=count%1000000007;
    return count; 
  }
  //归并排序
  public void mergeSortCore(int[] arr, int start, int end){
    if(start>=end){
      return;
    }
    int mid=(end+start)/2;
    mergeSortCore(arr,start,mid);
    mergeSortCore(arr,mid+1,end);
    merge(arr,start,mid,end);
  }
  public void merge(int[] arr, int start, int mid, int end){
    int[] temp=new int[end-start+1]; //辅助数组
    int i=end-start, p1=mid, p2=end;
    //有序的辅助数组
    while(p1>=start&&p2>mid){
      if(arr[p1]>arr[p2]){
        //如果前面大于后面的话，有p2-mid个逆序对
        count=(count+p2-mid)%1000000007;
        temp[i]=arr[p1];
        i--;
        p1--;
      }else {
        temp[i]=arr[p2];
        i--;
        p2--;
      }
    }
    while(p1>=start){
      temp[i--]=arr[p1--];
    }
    while(p2>mid){
      temp[i--]=arr[p2--];
    }
    for(int j=0;j<temp.length;j++){
      arr[start+j]=temp[j];
    }
  }
}