java实现求逆序对

1 问题描述
给定一个随机数数组，求取这个数组中的逆序对总个数。要求时间效率尽可能高。

那么，何为逆序对？

引用自百度百科：

设 A 为一个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。
如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数。
例如，数组（3，1，4，5，2）的逆序对有(3,1),(3,2),(4,2),(5,2)，共4个。

2 解决方案
2.1 蛮力法
初步一看，使用蛮力是最直接也最简单的方法，但是时间效率为O(n^2)。

即从第1个元素，开始依次和后面每一个元素进行大小比较，若大于，则逆序对个数加1。

package com.liuzhen.systemExe;

public class Main{
    
    //蛮力法求取数组A中逆序对数
    public int bruteReverseCount(int[] A) {
        int result = 0;
        for(int i = 0;i < A.length;i++) {
            for(int j = i;j < A.length;j++) {
                if(A[i] > A[j])
                    result++;
            }
        }
        return result;
        
    }
    
    //获取一个随机数数组
    public int[] getRandomArray(int n) {
        int[] result = new int[n];
        for(int i = 0;i < n;i++) {
            result[i] = (int)( Math.random() * 50);  //生成0~50之间的随机数
        }
        return result;
    }
    
    public static void main(String[] args){
        long t1 = System.currentTimeMillis();
        Main test = new Main();
        int[] A = test.getRandomArray(50000);
        int result = test.bruteReverseCount(A);
        long t2 = System.currentTimeMillis();
        System.out.println("使用蛮力法得到结果："+result+"， 耗时："+(t2 - t1)+"毫秒");
    }
}

运行三次的结果：

使用蛮力法得到结果：612226389， 耗时：8094毫秒


使用蛮力法得到结果：610311942， 耗时：8015毫秒


使用蛮力法得到结果：610657465， 耗时：8079毫秒

2.2 分治法（归并排序）
除了蛮力法，此处可以借用归并排序的思想来解决此题，此时时间复杂度为O（n*logn）。归并排序，具体是先进行对半划分，直到最后左半边数组只有一个元素，右半边数组中也只有一个元素时，此时开始进行回溯合并。那么，计算逆序对个数的关键，就在于此处的回溯合并过程，当左半边元素（PS：回溯过程中，左半边和右半边元素均已是升序排序）中出现大于右半边元素时，那么左半边这个元素及其后面的所有元素均大于这个右半边元素，记这些元素个数为len，那么逆序对个数要自增len。

package com.liuzhen.systemExe;

public class Main{
    
    public long count = 0;   //全局变量，使用合并排序，计算逆序对数
    //使用归并排序方法计算数组A中的逆序对数
    public void getReverseCount(int[] A) {
        if(A.length > 1) {
            int[] leftA = getHalfArray(A, 0);   //数组A的左半边元素
            int[] rightA = getHalfArray(A, 1);  //数组A的右半边元素
            getReverseCount(leftA);
            getReverseCount(rightA);
            mergeArray(A, leftA, rightA);
        }
    }
    //根据judge值判断，获取数组A的左半边元素或者右半边元素
    public int[] getHalfArray(int[] A, int judge) {
        int[] result;
        if(judge == 0) {   //返回数组A的左半边
            result = new int[A.length / 2];
            for(int i = 0;i < A.length / 2;i++)
                result[i] = A[i];
        } else {    //返回数组的右半边
            result= new int[A.length - A.length / 2];
            for(int i = 0;i < A.length - A.length / 2;i++)
                result[i] = A[A.length / 2 + i];
        }
        return result;
    }
    //合并数组A的左半边和右半边元素，并按照非降序序列排列
    public void mergeArray(int[] A, int[] leftA, int[] rightA) {
        int len = 0;
        int i = 0;
        int j = 0;
        int lenL = leftA.length;
        int lenR = rightA.length;
         while(i < lenL && j < lenR) {
             if(leftA[i] > rightA[j]) {
                 A[len++] = rightA[j++]; //将rightA[j]放在leftA[i]元素之前，那么leftA[i]之后lenL - i个元素均大于rightA[j]
                 count += (lenL - i);   //合并之前，leftA中元素是非降序排列，rightA中元素也是非降序排列。所以，此时就新增lenL -　i个逆序对
             } else {
                 A[len++] = leftA[i++];
             }
         }
         while(i < lenL)
             A[len++] = leftA[i++];
         while(j < lenR)
             A[len++] = rightA[j++];
    }
    //获取一个随机数数组
    public int[] getRandomArray(int n) {
        int[] result = new int[n];
        for(int i = 0;i < n;i++) {
            result[i] = (int)( Math.random() * 50);  //生成0~50之间的随机数
        }
        return result;
    }
    
    public static void main(String[] args){
        long t1 = System.currentTimeMillis();
        Main test = new Main();
        int[] A = test.getRandomArray(50000);
        test.getReverseCount(A);
        long t2 = System.currentTimeMillis();
        System.out.println("分治法得到结果："+test.count+"， 耗时："+(t2 - t1)+"毫秒");
    }
}

运行三次结果：

分治法得到结果：612226489， 耗时：36毫秒

分治法得到结果：610481152， 耗时：35毫秒

分治法得到结果：612161208， 耗时：32毫秒