数据结构 归并排序

　　归并排序采用了分治的思想（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之）。归并指将两个或两个以上的有序表组合成一个新的有序表。假设待排序表有n个元素，看成是n个有序的子表，每个子表长度为1，然后两两归并，得到n/2个长度为2或1的有序表，继续两两归并，直到合并成一个长度为n的有序表为止，这种排序方法称为2路归并排序。

　　

　　合并相邻有序子序列

　　将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]。

　　

　　

　　求逆序数：归并排序将数组a[l,h]分成两半a[l,mid]和a[mid+1,h]后分别进行归并排序，然后再将这两半合并起来。在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，不产生逆序数；当a[i]>a[j]时，在前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并排序的合并过程中计算逆序数。

　　题目来源：数组中的逆序对

public class MergeSort {
    // 待排序数组
    private int[] arr;
    // 逆序对总数
    private int result;
    
    // 归并两个数组
    private void merge(int left, int mid, int right) {
        int i = left, j = mid + 1, k = 0;
        int[] tempArr = new int[right - left + 1];
        
        while (i <= mid && j <= right) {
            if (arr[i] > arr[j]) {
                tempArr[k++] = arr[j++];
                result += mid + 1 - i;
                // 避免溢出
                result %= 1000000007;
            } else {
                tempArr[k++] = arr[i++];
            }
        }
        
        while (i <= mid) {
            tempArr[k++] = arr[i++];
        }
        while (j <= right) {
            tempArr[k++] = arr[j++];
        }
        
        System.arraycopy(tempArr, 0, arr, left, k);
    }
    
    // 归并排序
    private void mergeSort(int left, int right) {
        if (left < right) {
            int mid = (left + right) >> 1;
            mergeSort(left, mid);
            mergeSort(mid + 1, right);
            merge(left, mid, right);
        }
    }
    
    // 获取逆序数
    public int getResult(int[] array) {
        if (array == null || array.length <= 1) {
            return 0;
        }
        
        arr = array;
        result = 0;
        mergeSort(0, arr.length - 1);
        
        return result;
    }
}

　　测试用例：

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class MergeSortTest {
    MergeSort mergeSort;
    
    @Before
    public void setUp() throws Exception {
        mergeSort = new MergeSort();
    }

    @Test
    public void test() {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 0};
        assertEquals(7, mergeSort.getResult(arr));
    }

}

　　测试结果：

　　

　　2路归并排序性能分析：

　　空间复杂度：2个有序表归并时最多需要n个单元的辅助空间，所以空间复杂度为O(n)。

　　时间复杂度：每一趟归并的时间复杂度为O(n)，需要log₂n趟归并，所以时间复杂度为O(nlog₂n)。最好、最坏和平均时间复杂度均为O(nlog₂n)。

　　稳定性：2个有序表归并时不会改变相同元素的相对次序，所以2路归并排序是稳定的。

　　Java中Arrays.sort()方法采用了一种名为TimeSort的排序算法，是归并排序的优化版本。

　　

　　参考资料

　　《2017年数据结构联考复习指导》 P304-305

　　图解排序算法(四)之归并排序

　　归并排序求逆序对