數組的逆序度：用冒泡排序方法超時了，該怎麼辦？

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;”