分治策略

分治的策略就是将一个大问题，分解成一个一个小问题。

伪代码：

1 合并排序

手写代码：

public static void MergeSort(int[] A){
    mergeSort(A,0,A.length);
}
public static void mergeSort(int[] A,int l, int r){
    if(r-l <=1) return;
    int mid = (l+r+1)/2;
    //拆分
    mergeSort(A,l,mid);
    mergeSort(A,mid,r);
    //合并
    merge(A,l,mid,r);
}

private static void merge(int[] A, int l, int mid, int r) {
    int[] B = Arrays.copyOfRange(A,l,mid+1);
    int[] C = Arrays.copyOfRange(A,mid,r+1);
    B[B.length -1] = C[C.length -1] = Integer.MAX_VALUE;
    int i=0,j = 0;
    for(int k = l; k<r; k++){
        if(B[i] < C[j]){
            A[k] = B[i++];
        }else{
            A[k] = C[j++];
        }
    }
}

merge合并过程：

归并排序他是需要开辟N个空间的，作为辅助数组。时间复杂度为NlogN。

2 快速排序

同样快速排序跟归并排序有相似之处，将一个原问题拆分成两个子问题。

快速排序将小于x的值放到左边，大于x的值放到右边。x也叫做基准

代码如下：

public static void quickSort(int[] A , int l , int r){
    if(r-l <=1){
        return;
    }
    //选择最左边的元素构造子问题集合
    //小于x的放左边，大于x的放右边
    //int x = A[l];
    // i 代表x的位置
    int i = partition(A,l,r);

    quickSort(A,l,i);
    quickSort(A,i+1,r);
}

private static int partition(int[] A, int l, int r) {
    int x = A[l];
    int i = l +1;
    int j = r;
    while(i != j){
        if(A[i] <x){
            i++;
        }else{
            swap(A,i,--j);
        }
    }
    swap(A,i-1,l);
    return i-1;
}