编程题_数组中的逆序对

题目详述

链接：数组中的逆序对

题目解析

思路1：暴力解法

顺序扫描整个数组，每扫描到一个数字的时候，逐个比较该数字和它后面的数字的大小。如果后面的数字比它小，则这两个数字就组成一个逆序对。假设数组中含有n个数字，由于每个数字都要和O(n)个数字作比较，因此这个算法的时间复杂度是O(n²)。

对数组进行冒泡排序，交换次数即为逆序对个数。时间复杂度O(n²)。

思路2：分治思想（推荐）

链接：参考大佬的思路

采用归并排序的思路来处理，先分后治：先把数组分隔成子数组，先统计出子数组内部的逆序对的数目，然后再统计出两个相邻子数组之间的逆序对的数目。在统计逆序对的过程中，还需要对数组进行排序，其实这个排序过程就是归并排序的思路 。

逆序对的总数=左边数组中的逆序对的数量+右边数组中逆序对的数量+左右结合成新的顺序数组时中出现的逆序对的数量；

时间复杂度时O(n*log(n))。

 public class AntiOrder {
    public int count(int[] A, int n) {
        if (A == null || n == 0) {
            return 0;
        } return mergeSortRecursion(A, 0, n - 1);
    } 
    
    //递归实现归并排序
    public static int mergeSortRecursion(int[] arr, int l, int r) {
        if (l == r) {
            return 0; // 当待排序数组长度为1时，递归开始回溯，进行merge操作
        }
        int mid = (l + r) / 2;

        //逆序对的总数= 左边数组中的逆序对的数量+
        //     右边数组中逆序对的数量+左右结合成新的顺序数组时中出现的逆序对的数量
        return mergeSortRecursion(arr, l, mid) + 
                mergeSortRecursion(arr, mid + 1, r) +
                merge(arr, l, mid, r); //返回数组中的逆序对
    } 
    
    //合并两个已排好序的数组s[left...mid]和s[mid+1...right]
    public static int merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int index = 0;
        int i = left;
        int j = mid + 1;
        int inverseNum = 0;// 新增，用来累加数组逆序对
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[index++] = arr[i++];
            } else {
                // 当前一个数组元素大于后一个数组元素时，累加逆序对
                // s[i] > s[j] 推导出 s[i]...s[mid] > s[j]
                inverseNum += (mid - i + 1);
                temp[index++] = arr[j++];
            }
        } 
        while (i <= mid) {
            temp[index++] = arr[i++];
        } 
        while (j <= right) {
            temp[index++] = arr[j++];
        } 
        for (int k = 0; k < temp.length; k++) {
            arr[left++] = temp[k];
        } 
        return inverseNum; //返回合并过程中累加逆序对
    }
 }