時間規模爲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++;
        }
    }
}