查找逆序对

问题：

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

分析：

　　（1）使用蛮力法进行穷举：很遗憾，时间上只能通过50%；

　　（2）归并排序+插入排序：很遗憾，时间上只能通过75%

code1:穷举

　　

public int InversePairs(int[] array) {
        if (array == null || array.length <= 1) {
            return 0;
        }
        // 暴力破解：时间复杂度不满足
        long count = 0;
        for (int i = 1; i < array.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (array[j] > array[i]) {
                    count++;
                }
            }
        }
        int result = (int) count % 1000000007;
    }

code2：归并+插入

public int InversePairs(int[] array) {
        if (array == null || array.length <= 1) {
            return 0;
        }
        // 借鉴别人的思想，使用归并排序
        long res = mergeSort(array, 0, array.length - 1);
        // System.out.println(Arrays.toString(array));
        // System.out.println(res);
        return (int) (res % 1000000007);
    }
// 改进的归并排序
    public long mergeSort(int[] dp, int start, int end) {
        int len = (end - start);
        if (len == 0) {
            return 0;
        } else if (len == 1) {
            if (dp[start] > dp[end]) {
                int temp = dp[end];
                dp[end] = dp[start];
                dp[start] = temp;
                return 1;
            } else {
                return 0;
            }
        } else {
            int mid = len / 2;
            long right = mergeSort(dp, start, start + mid);
            long left = mergeSort(dp, start + mid + 1, end);
            long count = 0;
            // 子序列使用插入排序
            for (int i = start + mid + 1; i <= end; i++) {
                int cur = dp[i];
                int j;
                for (j = i - 1; j >= start; j--) {
                    if (dp[j] > cur) {
                        dp[j + 1] = dp[j];
                        count++;
                    } else {
                        break;
                    }
                }
                if (j != i - 1) {
                    dp[j + 1] = cur;
                }
            }
            return (count + right + left);
        }
    }

code3:纯归并