归并排序（分治思想）以及时间、空间复杂度分析

分治法：

把一个复杂问题分解为很多规模较小的子问题，然后解决这些子问题，最后把解决的子问题合并起来。

基本特征：

1.问题分解到一定规模容易解决。

2.子问题是相同类型的子问题，（最优子结构）递归的思想。

3.子问题的解可以合并，而且相互独立。

归并排序

将要排序的元素划分为单个的元素（分），然后一步步将分开的元素合并起来，同时进行排序。（归）。如下图所示：

分到最后，每个元素都是单独的一组，第一次拆分的数列是[52,45,77,33]和[4,5,22,77,43]，再对这两个序列进行归并时，早就已经排好序了。

时间复杂度

空间复杂度

递归代码的空间复杂度并不能像时间复杂度那样累加。尽管每次合并操作都需要申请额外的内存空间，但在合并完成之后，临时开辟的内存空间就被释放掉了。在任意时刻，CPU 只会有一个函数在执行，也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过 n 个元素的大小，所以归并排序的空间复杂度是 O(n)。
 

import java.util.Arrays;

public class Guibing {
    public static void merge(int[] a,int low,int mid,int high){
        int[] temp = new int[high-low+1];
        int i = low;
        int j = mid+1;
        int k = 0;
//        治
        while(i<=mid&&j<=high){
            if(a[i]<a[j]){
                temp[k] = a[i];
                k++;
                i++;
            }else {
                temp[k] = a[j];
                k++;
                j++;
            }
        }
        //将剩下的元素
        while(i<=mid){
            temp[k] = a[i];
            k++;
            i++;
        }
        while(j<=high){
            temp[k] = a[j];
            k++;
            j++;
        }
for (int k2 = 0;k2<temp.length;k2++)
    a[k2+low] = temp[k2];

    }
    public static void mergeSort(int[] a,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
//            分
            mergeSort(a,low,mid);
            mergeSort(a,mid+1,high);
            //归
            merge(a,low,mid,high);
            System.out.println(Arrays.toString(a));
            System.out.println(mid);
        }
    }
    public static void main(String[] args) {
        int a[] = {52,45,77,33,4,5,22,77,43};
        mergeSort(a,0,a.length-1);
        System.out.println("排序的结果"+Arrays.toString(a));
    }
}