数组的逆序度：用冒泡排序方法超时了，该怎么办？

leetcode 上有这么一道题目，逆序度

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例 1:

输入: [7,5,6,4] 输出: 5
逆序对：7-5， 7-6， 7-4， 5-4， 6-4

我上手就用冒泡排序的思想，来做，不成想超时了……

    public int reversePairs(int[] nums) {
        if(nums == null || nums.length < 2) return 0;
        int n = nums.length;
        int count = 0;
        for(int i = 0; i < n - 1; i++){
            for(int j = i + 1; j < n; j++){
                if(nums[i] > nums[j]){
                    count++;
                }
            }
        }
        return count;
    }

冒泡排序：时间复杂度 O(n^2)，空间复杂度O(1)，超时只说明思路是对的。然后看了题解，要用归并排序

    public int reversePairs(int[] nums) {
        if(nums == null || nums.length < 2) return 0;
        int[] temp = new int[nums.length];
        return recursion(nums, 0, nums.length-1, temp);

    }

    private int recursion(int[] nums, int begin, int end, int[] temp){
        if(begin >= end){
            return 0;
        }
        int mid = (end - begin)/2 + begin;
        int before = recursion(nums, begin, mid, temp);
        int after = recursion(nums, mid +1, end, temp);
        int m = merge(nums, begin, mid, end, temp);
        return before+after+m;
    }

    /*
    将有序的两列合并为列
    */
    private int merge(int[] nums, int begin, int mid, int end, int[] temp){
        int before = begin;
        int after = mid + 1;
        int index = begin;
        int count = 0;
        while(before <= mid && after <= end){
            if(nums[before] > nums[after]){
                //假如左边有序的元素是4，5，右边有序的元素是3，6。此次将3放入临时数组，
                //逆序度，此时就要加2（左边最小的元素比右边开头元素大） 
                count += mid - before + 1;
                temp[index++] = nums[after++];
            }else{
                temp[index++] = nums[before++];
            }
        }
        // 右边的元素有剩余，一次性复制到临时数组中
        if(before == mid + 1){
            System.arraycopy(nums, after, temp, index, end - after + 1);
        }
        // 左边的元素有剩余，一次性复制到临时数组中
        if(after ==  end + 1){
            System.arraycopy(nums, before, temp, index, mid - before + 1);
        }
        // 将排好序的元素，复制到源数组中（覆盖）
        System.arraycopy(temp, begin, nums, begin, end - begin + 1);
        return count;
    }

归并排序，时间复杂度O(logn)，空间复杂度O(n)，通过了。 其实核心就是在归并排序中，加了一行代码来计算逆序度“count += mid - before + 1;”