剑指Offer（35）：数组中的逆序对

一、题目描述

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

---

二、解题思路

分治思想，采用归并排序的思路来处理。在合并两个有序序列时，同时计算逆序对数。
对于两个升序序列，设置两个下标：两个有序序列的末尾。
每次比较两个末尾值，如果前末尾大于后末尾值，则有“后末尾指针减中间值”个逆序对，并移动后末尾指针；否则不构成逆序对，向前移动前末尾指针。然后把较大值拷贝到辅助数组（即合并完的升序序列）的末尾。每次在合并前，先递归地处理左半段、右半段，则左、右半段有序，且左右半段的逆序对数量可得，再计算左右半段合并时逆序对的个数。
逆序对的总数=左边数组中的逆序对的数量+右边数组中逆序对的数量+左右结合成新的顺序数组时出现的逆序对数量。

例如：
数组：{6，5，7，8，3，2，1，4}
分成左右两部分
{6，5，7，8} {3，2，1，4}
再分
{6，5}{7，8} {3，2}{1，4}
再分
{6}{5} {7}{8} {3}{2} {1}{4}
然后一边归并排序一边计数
第一步：
{6} {5} 一对逆序对，排序后变成{5，6}
{7} {8} 零对逆序对，排序后不变仍旧是{7，8}
{3} {2} 一对逆序对，排序后变成{2，3}
{1} {4} 零对逆序对，排序后不变仍旧是{1，4}
第二步：（只比较前后两个之间，不比较内部，因为上一步已经比较完内部）
{5，6} {7，8} 零对逆序对，排序后不变仍旧是{5，6，7，8}
{2，3} {1，4} 两对逆序对({2，1}和{3，1})，排序后变成{1，2，3，4}
第三步：
{5，6，7，8} {1，2，3，4}
指针：i->8，j->4。8>4，则8>1、2、3，计数加入j-mid（7-3=4），i指针向前移动。
{5，6，7，8} {1，2，3，4}
指针：i->7，j->4。7>4，则7>1、2、3，计数加入j-mid（7-3=4），i指针向前移动。
…直至i移动到head。
另一种情况：
{1，3，7，8} {2，4，5，9}
指针：i->8，j->9。8<9，j指针向前移动。
{1，3，7，8} {2，4，5，9}
指针：i->8，j->5。8>5，则8>2、4，计数加入j-mid（6-3=3），i指针向前移动。
{1，3，7，8} {2，4，5，9}
指针：i->7，j->5。7>5，则7>2、4，计数加入j-mid（6-3=3），i指针向前移动。
{1，3，7，8} {2，4，5，9}
指针：i->3，j->5。3<5，j指针向前移动。
…直至j移动到mid或者i移动到head。

---

三、编程实现

public class Solution {
    public static int InversePairs(int[] array) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        int count = InversePairsCore(array, copy, 0, array.length - 1);
        return count;
    }

    private static int InversePairsCore(int[] array, int[] copy, int head, int tail) {
        if (head == tail) {
            return 0;
        }
        // mid的位置
        int mid = (head + tail) >> 1;
        // 递归，分别计算左边和右边内部的逆序对个数
        int leftCount = InversePairsCore(array, copy, head, mid) % 1000000007;
        int rightCount = InversePairsCore(array, copy, mid + 1, tail) % 1000000007;
        // count计数左右两者之间的对数
        int count = 0;
        // i指向mid，j指向tail
        int i = mid;
        int j = tail;
        // 临时数组的指针，指向tail
        int tempCopy = tail;

        while (i >= head && j > mid) {
            // 如果arr[i]大于arr[j]
            if (array[i] > array[j]) {
                // i指向的数大于右半部分所有的数，计数加入j-mid
                count += j - mid;
                // 临时数组存放i指向的数，同时tempCopy和i都向前移动
                copy[tempCopy--] = array[i--];
                if (count >= 1000000007) {
                    count %= 1000000007;
                }
            // 如果arr[i]小于arr[j]，tempCopy和j都向前移动
            } else {
                copy[tempCopy--] = array[j--];
            }
        }
        // 移动完之后将没存放的数字存入临时数组，例如[1,2,3,4][5,6,7,8]，
        // 临时数组存完后面四个[5,6,7,8]，j移动到mid移动终止，将剩下的[1,2,3,4]存入临时数组
        for (; i >= head; i--) {
            copy[tempCopy--] = array[i];
        }
        // 同理，这也是移动完之后将没存放的数字存入临时数组，例如[5,6,7,8][1,2,3,4]，
        // 临时数组存完后面四个[5,6,7,8]，i移动到head移动终止，将剩下的[1,2,3,4]存入临时数组
        for (; j > mid; j--) {
            copy[tempCopy--] = array[j];
        }
        // 将临时数组复制到原数组，以便递归
        System.arraycopy(copy, head, array, head, tail - head + 1);
        return (leftCount + rightCount + count) % 1000000007;
    }
}

---