求逆序对

1 原理

归并排序求逆序对 ，归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并排序中的合并过程中计算逆序数

2 实现

import sort.InsertionSort;

/**
 * 求逆序对 leetcode135
 * 
 * @author xld 使用归并排序进行操作 merge函数求出在arr[l...mid]和arr[mid+1...r]有序的基础上,
 *         arr[l...r]的逆序数对个数
 */
public class InversionCount {
    public static long solve(int[] arr) {
        int n = arr.length;
        return solve(arr, 0, n - 1);
    }

    public static long solve(int[] arr, int l, int r) {

        if (l >= r)
            return 0;
        // 当然 为了防止溢出 可以这样写 mid=l+(r-l)/2
        int mid = (l + r) / 2;

        // 求出 arr[l...mid] 范围的逆序数
        long res1 = solve(arr, l, mid);

        // 求出 arr[mid+1...r] 范围的逆序数
        long res2 = solve(arr, mid + 1, r);

        return res1 + res2 + merge(arr, l, mid, r);

    }

    public static long merge(int[] arr, int l, int mid, int r) {
        // 辅助数组 进行归并
        int[] aux = new int[r - l + 1];
        int auxIndex = 0;
        // 初始化辅助数组
        for (int i = l; i <= r; i++)
            aux[auxIndex++] = arr[i];

        // 左数组索引
        int i = l;
        // 右数组索引
        int j = mid + 1;
        // 逆序对数
        long res = 0;

        for (int k = l; k <= r; k++) {
            if (i > mid) {
                arr[k] = aux[j - l];
                j++;
            } else if (j > r) {
                arr[k] = aux[i - l];
                i++;
            } else if (aux[i - l] <= aux[j - l]) {
                arr[l] = aux[i - l];
                i++;
            } else {
                arr[k] = aux[j - l];
                j++;
                // 此时, 因为右半部分k所指的元素小
                // 这个元素和左半部分的所有未处理的元素都构成了逆序数对
                // 左半部分此时未处理的元素个数为 mid - j + 1
                res += (long) (mid - i + 1);
            }
        }
        return res;
    }

    // 测试InsertionSort
    public static void main(String[] args) {
        int[] arr = { 10, 9, 8, 7, 5, 12, 4, 3, 2, 1 };
        long res = InversionCount.solve(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            System.out.print(' ');
        }
        System.out.println(res);
    }
}