时间规模为nlogn的数列逆序对数量计算

逆序对

假设A[1…n]是一个有n个不同数的数组, 若i<j且A[i]>A[j], 则对偶(i,j)称为A的一个逆序对

设计思路

想要把算法规模控制在nlgn级别, 自然会联系到归并排序算法. 如果依赖归并排序的过程, 那么其中需要统计的则是每层递归执行合并时后序数组中每个元素针对前序数组的逆序和, 也就是每次获取后序数组元素时前序数组剩余元素的个数之和.

算法实现

import java.util.Arrays;

/**
 * Created by buka on 2017/11/7.
 */
public class Itest {

    static int cnt = 0;

    public static void main(String[] args) {
        int[] array = new int[]{3, 41, 52, 26, 38, 57, 9, 49};
        mergeSort(array, 0, 7);
        System.out.println(cnt);
        System.out.println(Arrays.toString(array));
    }

    static void mergeSort(int[] arr, int p, int r) {
        int q = (p + r) / 2;
        if (r > q) {
            mergeSort(arr, p, q);
            mergeSort(arr, q + 1, r);
            merge(arr, p, q, r);
        }
    }

    static void merge(int[] arr, int p, int q, int r) {
        int n1 = q - p + 1;
        int n2 = r - q;
        int L[] = new int[n1];
        int R[] = new int[n2];
        for (int i = 0; i < n1; i++) {
            L[i] = arr[p + i];
        }
        for (int j = 0; j < n2; j++) {
            R[j] = arr[q + j + 1];
        }
        int i = 0;
        int j = 0;
        int k = p;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
                cnt += n1 - i;
            }
            k++;
        }
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
}