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;
  }

public static int inversePairs2(int[] array) {
    if (array == null || array.length < 2) {
      return 0;
    }
    int count = mergeSort(array, 0, array.length - 1);
    return count % 1000000007;
  }
 
  private static int mergeSort(int[] array, int start, int end) {
    if (start >= end) {
      return 0;
    }
 
    // 找到數(shù)組的中點，分割為兩個子數(shù)組，遞歸求解
    int middle = (start + end) / 2;
    int left = mergeSort(array, start, middle);
    int right = mergeSort(array, middle + 1, end);
 
    // 存儲歸并后的數(shù)組
    int[] copy = new int[array.length];
    System.arraycopy(array, start, copy, start, end - start + 1);
    // 從兩個子數(shù)組的尾部開始遍歷
    int i = middle;
    int j = end;
    int copyIndex = end;
    // 記錄逆序對的數(shù)量
    int count = 0;
 
    while (i >= start && j >= middle + 1) {
      // 數(shù)組是升序的
      // 如果左邊數(shù)組比右邊數(shù)組大，則將大的放入存儲數(shù)組中
      // 并且累加逆序對，應為是有序的，所以左邊數(shù)組的第i個元素比第j個及其之前的數(shù)都大
      if (array[i] > array[j]) {
        copy[copyIndex--] = array[i--];
        count += (j - middle);
      } else {
        copy[copyIndex--] = array[j--];
      }
    }
 
    // 將子數(shù)組剩余的部分一次寫入歸并后的存儲數(shù)組
    while (i >= start) {
      copy[copyIndex--] = array[i--];
    }
    while (j >= middle + 1) {
      copy[copyIndex--] = array[j--];
    }
 
    // 將本次兩個子數(shù)組的合并寫入原數(shù)組中
    for (int k = start; k <= end ; k++) {
      array[k] = copy[k];
    }
    return left + right + count;
  }