归并排序及数组中逆序对的数量

归并排序

首先我们来回忆一下归并排序的主要思想：

1. 首先考虑如何让将两个有序子序列进行合并？这个方法就是下面代码中的 merge 方法，如果我们能把两个子有序序列合并，那么就可以将短子序列合并为更长的子序列，直到完成源数组的排序。
2. 如何获取最开始合并的有序子序列呢？通过不断将数组一分为二，直到每个子序列只剩一个元素的时候，子序列就是有序的了，这样一来，我们就可以实现子有序序列的合并了。

具体的理解推荐学习这个视频讲解，老师讲的很仔细，跟着理解一遍自己就能利用熟悉的语言进行实现。

在这个算法里我们需要注意几点：

1. 我们为了将原数组排序，需要借助一个临时数组 tmp ，两个有序子序列，每次都需要将排好序的元素放在 tmp 里，然后再将元素从 tmp 中捣回原数组，我们可以在合并开始就将 tmp 作为参数传递进去，不要在合并方法里面新建 tmp，那样的话整个算法运行期间会不断声明数组，销毁数组。
2. 对两个有序子序列进行合并，常规思想都是从头往后比较，谁小就放谁放到 tmp 中，tmp的 下标从头开始；但是对于一些变种，我们就是需要从后往前比较，谁大就把谁放在 tmp 的后面，tmp 下标从尾部开始，比如我们之后介绍的扩展题：求数组中逆序对的数量。就会利用到这个细节。
3. 算法的最好和最坏时间复杂度都是 O(nlgn)，且是稳定的排序。

Java实现 

public class MyMergeSort {
    public static void mergeSort(int[] nums) {
        mSort(nums, new int[nums.length], 0, nums.length-1);
    }

    /**
     * 先分：一直划分划分到只剩一个元素为一个子序列
     * @param nums      原始数组
     * @param tmp       临时数组
     * @param leftStart 左边子序列起始下标
     * @param rightEnd  右边子序列结束下标
     */
    private static void mSort(int[] nums, int[] tmp, int leftStart, int rightEnd) {
        if (leftStart == rightEnd) {
            return;
        }
        // 一分为二
        int mid = leftStart + (rightEnd-leftStart)/2;
        // 分左边子数组
        mSort(nums, tmp, leftStart, mid);
        // 分右边子数组
        mSort(nums, tmp, mid+1, rightEnd);
        // 合并。
        merge(leftStart, mid+1, rightEnd, tmp, nums);
    }

    /**
     * 再治：对两个有序子序列进行合并。
     * @param leftStart  左边子序列的开始下标
     * @param rightStart 右边子序列的开始下标
     * @param rightEnd   右边子序列的结束下标
     * @param tmp         临时数组，前后两个子数组的结果排序结果会保存在 tmp 中
     * @param nums       原始数组
     */
    private static void merge(int leftStart, int rightStart, int rightEnd, int[] tmp, int[] nums) {
        int leftEnd = rightStart-1;
        // tmpStart 代表此次元素放在 tmp 的哪个下标位置，
        int tmpStart = leftStart;
        int length = rightEnd-leftStart+1;
        while (leftStart <= leftEnd && rightStart <=rightEnd) {
            // 降序
            //tmp[tmpStart ++] = nums[leftStart] > nums[rightStart] ? nums[leftStart++] : nums[rightStart++];

            // 升序
            tmp[tmpStart ++] = nums[leftStart] < nums[rightStart] ? nums[leftStart++] : nums[rightStart++];
        }
        while (leftStart <= leftEnd) {
             tmp[tmpStart ++] = nums[leftStart ++];
        }
        while (rightStart <= rightEnd) {
            tmp[tmpStart ++] = nums[rightStart ++];
        }
        // 将 tmp 里有序的元素捣回到原数组。
        for (int i=0; i<length; i++, rightEnd--) {
            nums[rightEnd] = tmp[rightEnd];
        }
    }
    
    public static void main(String[] args) {
        int[] nums = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 10 };
        mergeSort(nums);
        for (int x : nums) {
            System.out.print(x+ " ");
        }
    }
}

 

拓展

求数组中的逆序对

　　什么是逆序对呢，对于数组 nums ，若满足

i < j && nums[i] > nums[j]

则称 nums[i] 和 nums[j] 就构成了一对逆序对。举个例子：对于数组：[ 1，5，3，2，6 ]，共存在 3 组逆序对，分别是 [5, 3]、[5，2]、[3，2] 。对于最简单的思路就是用两次 for 循环对每个元素查找其构成的逆序对数量，时间复杂度为O（n^2）。如果借用归并排序的思想，可以达到和归并排序一样的时间复杂度O(nlgn)。

　　对原数组进行归并排序，在合并操作的时候就可以获得前后两个子序列的逆序对。这里是从子序列的尾部往前移动的。

Java实现

 

public class CountReverse {
    public static int inversePairs(int[] nums){
        if( nums == null ||nums.length <= 1) {
            return 0;
        }
        int[] tmp = new int[nums.length];

        return mergeCount(nums, tmp, 0, nums.length-1);
    }

    public static int mergeCount(int[] nums, int[] tmp, int leftStart, int rightEnd){
        if(leftStart == rightEnd){
            tmp[leftStart] = nums[leftStart];
            return 0;
        }
        int mid = leftStart + (rightEnd - leftStart)/2;
        
        int leftCount = mergeCount(nums, tmp, leftStart, mid);
        int rightCount = mergeCount(nums, tmp, mid+1, rightEnd);

        int leftEnd = mid;// i 初始化为前半段最后一个数字的下标

        int tmpEnd = rightEnd;//辅助数组复制的数组的最后一个数字的下标
        
        int count = 0; //计数--逆序对的数目

        while(leftStart <= leftEnd && mid+1 <= rightEnd){
            if(nums[leftEnd] > nums[rightEnd]){
                tmp[tmpEnd --] = nums[leftEnd --];
                // 因为 是两个有序的子序列。
                count += rightEnd - mid;
            }else{
                tmp[tmpEnd--] = nums[rightEnd--];
            }
        }

        while (leftEnd >= leftStart) {
            tmp[tmpEnd --] = nums[leftEnd --];
        }

        while (rightEnd >= mid + 1) {
            tmp[tmpEnd --] = nums[rightEnd --];
        }
        
        return leftCount + rightCount + count;
    }

    public static void main(String[] args) {
        int[] nums = new int[] {1, 5, 3, 2, 6};
        System.out.println(inversePairs(nums));
    }
}