归并排序 O(nLogn)

    //对数组[l...r] 全闭空间排序
    public static void mergeSort(int[] arr) {

        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int l, int r) {
        if (l == r) {//只有一个元素了，那么它就是有序的
            return;
        } else {
            //找到中间边界mid 拆分2个数组[l...mid]和[mid+1...r]
            int mid = (r - l) / 2 + l;
            //左边继续拆分
            mergeSort(arr, l, mid);
            //右边边继续拆分
            mergeSort(arr, mid + 1, r);

            //一直拆分到l==r 说明只有一个元素 retuen
            //然后开始回溯合并排序
            merge(arr, l, mid, r);
        }
    }

    public static void merge(int[] arr, int l, int mid, int r) {
        //1. l不一定是从0开始的 2.因为是 对数组[l...r] 全闭空间排序 所以要+1
        int[] temp = new int[r - l + 1];

        //赋值临时数组 也就是拆分左右数组，将arr拆分成arr1和arr2
        for (int i = l; i <= r; i++) {
            //上面说过l不是从0开始的  但是我们的temp是0开始的，所以要进行l的偏移
            temp[i - l] = arr[i];
        }

        int i = l, j = mid + 1;
        for (int k = l; k <= r; k++) {
            //当arr2排序完成 但是arr1还有元素 那么直接赋值
            if (j > r && i <= mid) {
                arr[k] = temp[i - l];
                i++;
                 //当arr1排序完成 但是arr2还有元素 那么直接赋值
            } else if (i > mid && j <= r) {
                arr[k] = temp[j - l];
                j++;
            } else if (temp[i - l] < temp[j - l]) {
                arr[k] = temp[i - l];
                i++;
            } else {
                arr[k] = temp[j - l];
                j++;
            }
        }
    }

/**
     * 自定向上排序
     *
     * @param arr 待排序数组
     * @param n   数组的长度
     */
    public static void mergeSort(int[] arr, int n) {
        /*
         * 数组分2层循环 第一层是确定分组后每个组的长度，按照上面图的图示所知
         * size分别为1,2,4,8...
         * 当size=1 那么arr1.length=1 arr2.length=1 所以 1-1 排序 最终 “每” 2个元素有序
         * 当size=2 那么arr1.length=2 arr2.length=2 所以 2-2 排序 最终 “每” 4个元素有序
         * 当size=4 那么arr1.length=4 arr2.length=4 所以 4-4 排序 最终 “每” 8个元素有序
         * 所以这层循环 就是为了帮助我们创建符合要求变化的size大小
         * 最开始数组长度=1 也就是1个元素 他就是有序的 那么size = 2 * size这个算式就帮助我们迭代创建size分别为1,2,4,8...
         *
         */
        for (int size = 1; size <= n; size = 2 * size) {
            /*
             *i表示的是每个要合并分作的起始坐标也就是left 我们知道 left-right是通过mid分成arr1和arr2的
             * 也就是[l...mid]-[mid+1...r] 等价于[l...size-1]和[size...r]
             * 所以i的取值变化为i = i + 2 * size
             * 同时i不能越界 所以i<n
             */
            for (int i = 0; i + size < n; i = i + 2 * size) {
                /*
                 * 上面分析[l...mid]-[mid+1...r] 等价于[l...size-1]和[size...r]
                 * 所以 i等价l i + size - 1等价mid i + size + size - 1等价r
                 * 虽然i<n合法 但是i + size可能越界，
                 * 同时当i+size>=n说明 只有arr1 arr2为null，那么也就不归并了 他就是有序的
                 * 因为从上面得知，归并的前提是arr1和arr2是有序的
                 * 
                 * 
                 * i + size + size - 1相当于r 他可能越界 所以Math.min(i + size + size - 1, n - 1)
                 * 
                 */
                merge(arr, i, i + size - 1, Math.min(i + size + size - 1, n - 1));
            }
        }
    }

 public static void mergeSort(int[] arr, int l, int r) {
        if (r-l<=15) {
           insertSort(arr,l,r);// 1 .
            return;
        } else {
            //找到中间边界mid 拆分2个数组[l...mid]和[mid+1...r]
            int mid = (r - l) / 2 + l;
            //左边继续拆分
            mergeSort(arr, l, mid);
            //右边边继续拆分
            mergeSort(arr, mid + 1, r);

            //一直拆分到l==r 说明只有一个元素 retuen
            //然后开始回溯合并排序
            if (arr[mid] > arr[mid + 1])//2.
                merge(arr, l, mid, r);
        }
    }

什么是逆序对.逆序对是判断一个数组有序程度的一个标示。一个完全有序的数组，逆序对个数=0
 1 2 3 4 5 6 8 7 一个逆序对   
 利用归并思想，当向上归并：
 
 2 3 6 8 ｜ 1 4 5 7 
 
 2与1比较 1<2  那么1比左边2 3 6 8 都要小那么此时逆序对4 
 继续归并到
 1 2 3 当4<6时 4比左边6 8 小 逆序对未2  
 
 最终将计数相加