《剑指Offer》求数组逆序对

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

例如在数组｛7，5，6，4｝中，一共存在5对逆序对，分别是｛7，6｝，｛7，5｝，｛7，4｝，｛6，4｝，｛5，4｝。

    看 到这个题目，我们的第一反应就是顺序扫描整个数组。每扫描到一个数组的时候，逐个比较该数字和它后面的数字的大小。如果后面的数字比它小，则这两个数字就组成一个逆序对。假设数组中含有n个数字。由于每个数字都要和O(n）个数字做比较，因此这个算法的时间复杂度为O(n2)。我们尝试找找更快的算法。

    我们以数组｛7，5，6，4｝为例来分析统计逆序对的过程，每次扫描到一个数字的时候，我们不能拿它和后面的每一个数字做比较，否则时间复杂度就是O(n2)因此我们可以考虑先比较两个相邻的数字。
方法一：暴力破解

public static int inversePairs(int[] array) {
    if (array == null || array.length < 2) {
      return 0;
    }
    int count = 0;
    for (int i = 0; i < array.length; i++) {
      for (int j = i + 1; j < array.length; j++) {
        if (array[i] > array[j]) {
          count++;
        }
      }
    }
    return count % 1000000007;
  }

方法二：利用分治策略


package com.atguigu.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class MergetSort {
   public static int count = 0;
   public static void main(String[] args) {
      int arr[] = { 2,1}; //

      //测试快排的执行速度
      // 创建要给80000个的随机的数组
      /*int[] arr = new int[8000000];
      for (int i = 0; i < 8000000; i++) {
         arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
      }*/
      System.out.println("排序前");
      Date data1 = new Date();
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      String date1Str = simpleDateFormat.format(data1);
      System.out.println("排序前的时间是=" + date1Str);
      
      int temp[] = new int[arr.length]; //归并排序需要一个额外空间
      mergeSort(arr, 0, arr.length - 1, temp);
      
      Date data2 = new Date();
      String date2Str = simpleDateFormat.format(data2);
      System.out.println("排序前的时间是=" + date2Str);
      
      System.out.println("逆序数=" + count);
   }
   

   //分+合方法
   public static void mergeSort(int[] arr, int left, int right, int[] temp) {
      if(left < right) {
         int mid = (left + right) / 2; //中间索引
         //向左递归进行分解
         mergeSort(arr, left, mid, temp);
         //向右递归进行分解
         mergeSort(arr, mid + 1, right, temp);
         //合并
         merge(arr, left, mid, right, temp);
         
      }
   }
   
   //合并的方法
   /**
    * 
    * @param arr 排序的原始数组
    * @param left 左边有序序列的初始索引
    * @param mid 中间索引
    * @param right 右边索引
    * @param temp 做中转的数组
    */
   public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
      
      int i = left; // 初始化i, 左边有序序列的初始索引
      int j = mid + 1; //初始化j, 右边有序序列的初始索引
      int t = 0; // 指向temp数组的当前索引

      //(一)
      //先把左右两边(有序)的数据按照规则填充到temp数组
      //直到左右两边的有序序列，有一边处理完毕为止
      while (i <= mid && j <= right) {//继续
         //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
         //即将左边的当前元素，填充到 temp数组 
         //然后 t++, i++
         if(arr[i] <= arr[j]) {
            temp[t] = arr[i];
            t += 1;
            i += 1;

         } else { //反之,将右边有序序列的当前元素，填充到temp数组
            temp[t] = arr[j];
            t += 1;
            j += 1;
            // 因为如果a[i]此时比右数组的当前元素a[j]大，  
            // 那么左数组中a[i]后面的元素就都比a[j]大  
            // 【因为数组此时是有序数组】  

            count ++;
         }
      }
      
      //(二)
      //把有剩余数据的一边的数据依次全部填充到temp
      while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
         temp[t] = arr[i];
         t += 1;
         i += 1;    
      }
      
      while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
         temp[t] = arr[j];
         t += 1;
         j += 1;    
      }
      
      
      //(三)
      //将temp数组的元素拷贝到arr
      //注意，并不是每次都拷贝所有
      t = 0;
      int tempLeft = left; // 
      //第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
      //最后一次 tempLeft = 0  right = 7
      while(tempLeft <= right) { 
         arr[tempLeft] = temp[t];
         t += 1;
         tempLeft += 1;
      }

   }

}