归并排序以及Tim排序

递归概念：方法自己调用自己。注意需要有返回条件，basecase。

归并排序：递归+合并。是分治思想的实践，在递归基础上的一种排序算法。稳定，速度仅次于快速排序。

归并排序思想：

• 分解（Divide）：将n个元素分成个含n/2个元素的子序列。
• 解决（Conquer）：用合并排序法对两个子序列递归的排序。
• 合并（Combine）：合并两个已排序的子序列已得到排序结果。

时空复杂度：

最好、最坏、平均时间复杂度：O(logN * N)。空间复杂度：O(N)。

应用：

java、python等中，对象的排序基本都是归并排序的方式。原因：对象存在多个属性，需要稳定。

默认的merge

static void merge(){
        int[] arr = {1,4,7,8,3,6,9};
        int mid = arr.length %2==1 ? arr.length / 2:arr.length/2 - 1;
        int[] temp = new int[arr.length];
        int i=0,j=mid+1,k=0;
        while (i <= mid && j < arr.length) temp[k++] = arr[i] <= arr[j] ? arr[i++]:arr[j++];
        while (i <= mid) temp[k++] = arr[i++];
        while (j < arr.length) temp[k++] = arr[j++];

        System.out.println(JSON.toJSONString(temp));
    }

最终算法实现

public static  void main(String[] args){

        int[] arr = {1,4,7,8,3,6,9};
        mergeSort(arr,0,arr.length-1);
        System.out.println(JSON.toJSONString(arr));

    }
    static void  mergeSort(int[] arr,int left,int right){
        if(left == right) return;
        /**分成两半，
         * 排左边
         * 排右边
        */
        int mid = left + (right - left) /2;
        mergeSort(arr,left,mid);
        mergeSort(arr,mid+1,right);
        merge(arr,left,mid+1,right);
    }


    static void merge(int[] arr, int leftPtr,int rightPtr, int rightBound){
//        int mid = arr.length %2==1 ? arr.length / 2:arr.length/2 - 1;
        int[] temp = new int[rightBound - leftPtr + 1];
        int i=leftPtr,j=rightPtr,k=0;
        while (i < rightPtr && j <= rightBound)
            temp[k++] = arr[i] <= arr[j] ? arr[i++]:arr[j++];

        while (i < rightPtr) temp[k++] = arr[i++];
        while (j <= rightBound) temp[k++] = arr[j++];

        for (int n=0;n<temp.length;n++){
            arr[leftPtr+n] = temp[n];
        }
    }

时间复杂度：

分治O(log2N)层，每层排序交换大概N次，因此时间复杂度：O(N logN)

空间复杂度：

最多只需要O(N)

归并排序改进：

多路归并：TimeSort和binarySort