数组中的逆序对

题目：

有一组数，对于其中任意两个数组，若前面一个大于后面一个数字，则这两个数字组成一个逆序对。请设计一个高效的算法，计算给定数组总的逆序对个数。

给定一个int数组A和它的大小n，请返回A中的逆序对个数。保证n小于等于5000.

测试样例：

【1,2,3,4,5,6,7,0】8

返回：7

解题思路：

思路一：暴力破解法 

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

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] data = in.next().split(",");
        int[] A = new int[n];
        for (int i = 0; i < n; i++){
            A[i] = Integer.parseInt(data[i]);
        }

        int count = 0;
        for (int i = 0; i < n-1; i++){
            for (int j = i+1; j < n; j++){
                if (A[i] > A[j]){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}

思路二：分治思想

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

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] data = in.next().split(",");
        int[] A = new int[n];
        for (int i = 0; i < n; i++) {
            A[i] = Integer.parseInt(data[i]);
        }
        System.out.println(count(A,n));
    }

        public static int count ( int[] A, int n){
            if (A == null || n == 0) {
                return 0;
            }
            return mergeSortRescursion(A, 0, n - 1);
        }

        public static int mergeSortRescursion ( int[] arr, int l, int r){
            if (l == r) {
                return 0;
            }
            int mid = (r + l) / 2;
            //逆序对的总数=左边数组中逆序对的数量+右边数组中逆序对的数量+左右结合成新的顺序数组时中出现的逆序对的数量
            return mergeSortRescursion(arr, l, mid) + mergeSortRescursion(arr, mid + 1, r) + merge(arr, l, mid, r);
        }

        public static int merge ( int[] arr, int left, int mid, int right){
            int[] tmp = 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]) {
                    tmp[index++] = arr[i++];
                } else {
                    //当前一个数组元素大于后一个数组元素时，累加逆序对
                    //s[i] > s[j] 推导出 s[i] ... s[mid] > s[j]
                    inverseNum += (mid - i + 1);
                    tmp[index++] = arr[j++];
                }
            }
            while (i <= mid) {
                tmp[index++] = arr[i++];
            }
            while (j <= right) {
                tmp[index++] = arr[j++];
            }
            for (int k = 0; k < tmp.length; k++) {
                arr[left++] = tmp[k];
            }
            return inverseNum;
        }
    }