合久必分，分久必合----归并排序

归并排序

归并排序就是采用分治的思想，将一个大问题才分成许多小问题，再将小问题一个一个解决点，最终解决了大问题。他是一种平衡的、二分的分治策略。
1、先分解：将待排序的元素一分为二。
2、治理：将两个子序列进行排序。
3、合并：将排好的有序子序列合并，得到最终的有序序列。

图解

复杂度分析

时间复杂度：分解仅仅需要确定中间mid的值，因此是常数时间O(1)；
解决子问题，递归调用两个规模的子序列，所需时间是2T(n/2)
合并算法可以在O(n)时间内完成。
所以最终算法时间复杂度是O(nlogn)。
空间复杂度：因为是递归调用，所以递归树的深度决定所占的栈空间，假设递归树的深度是x，那所占的函数栈空间就是n=2^x，所以n=O(logn)。

代码实现

package sort;

/**
 * 归并排序,时间复杂度是nlogn，空间复杂度logn(递归)
 */
public class MergeSort {
    public void merge(int A[],int low,int mid,int high){
        int [] array = new int[high-low+1];
        int i = low,j = mid+1,k = 0;
        while (i<=mid&&j<=high){
            if(A[i]<A[j]){
                array[k++] = A[i++];
            }else{
                array[k++] = A[j++];
            }
        }
        while (i<=mid){
            array[k++] = A[i++];
        }
        while (j<=high){
            array[k++] = A[j++];
        }
        for ( i = low,k=0; i <=high; i++) {
            A[i] = array[k++];
        }
    }
    public void mergeSort(int A[],int low,int high){
        if (low<high){
            int mid = (low+high)>>1;
            mergeSort(A,low,mid);  // 对low:mid的元素合并排序
            mergeSort(A,mid+1,high); // 对mid+1：high的元素合并排序
            merge(A,low,mid,high); // 最后在同一合并到一个数组中
        }
    }

    public static void main(String[] args) {
        MergeSort mergeSort = new MergeSort();
        int array [] = {12,3,4,21,32,5,8,10,9};
        mergeSort.mergeSort(array,0,array.length-1);
        for (int i : array) {
            System.out.print(i+" ");
            
        }
        // 3 4 5 8 9 10 12 21 32 
    }

}