十大排序之分治排序

1.归并排序

概念：将两个有序数组合并为一个有序数组，成为归并排序。

思路：注意，不是说分成两个真的只分成两个，然后把这两个分别用其他算法排序，然后再合起来，那样的话就太令人哈哈哈哈了。专业一点的应该是，把数组分成两份，然后再分，分到只剩一个元素的数组就一定有序了，那把一个元素的数组组合起来就是有序的了。这一听就是通过递归来做了。先写个函数分数组，再把merge过程实现

public static void mergeSort(int[] arr,int L,int R) {
    if(L>=R){
        return;
    }
    mergeSort(arr,L,L+(R-L)/2);
    mergeSort(arr,L+(R-L)/2+1,R);
    help(arr,L,R);
}
public static void help(int[] arr,int L,int R) {
    if(L>=R){
        return;
    }
    int[] arrTemp=new int[R-L+1];
    for (int i = 0; i < R-L+1; i++) {
        arrTemp[i]=arr[L+i];
    }
    int pL=0;
    int pR=(R-L)/2+1;
    int pArr=L;
    while (pL<=(R-L)/2&&pR<=R-L){
        if(arrTemp[pL]<arrTemp[pR]){
            arr[pArr++]=arrTemp[pL++];
        }else {
            arr[pArr++]=arrTemp[pR++];
        }
    }
    while (pL<=(R-L)/2){
        arr[pArr++]=arrTemp[pL++];
    }
    while (pR<=R-L){
        arr[pArr++]=arrTemp[pR++];
    }
}

2.快速排序 

概念：这个难以简单明了的解释，就是想快点排出来。

思路：把第一个元素作为基准，把小于它的都挪到它前面，大于它的都挪到它后面。但是按照这个思路实现就很烦，又不不可能找到一个小的就让他都往后挪挪，那就变成插入排序了。所以核心逻辑是交换，基准元素取出来，他那个位置放再放什么元素就不重要了，从后往前，找到比基准小的，就把这个e指针的元素放到基准那个位置，，这个是数组里面是有两个e指针元素，所以此时e指向的位置放其他元素的值也没有问题了，然后从基准那里往后找，找到比他大的就放到刚才e指针的位置。这样s指针的元素就有两个了，然后循环，这个是s和e就会相遇，相遇之后就将，基准赋值给这个位置，然后就完成一轮了。最后从基准那里将数组分成两个数组分治，直到都变成三个元素的数组或两个元素的数据，把基准放中间就一定有序了。

public static int[] quickSort(int[] arr) {
    help(arr,0,arr.length-1);
    return arr;
}
public static void help(int[] arr,int L,int R) {
    if(L>=R){
        return;
    }
    int base=arr[L];
    int pL=L;
    int pR=R;
    while(pL<pR){
        while (pL<pR&&arr[pR]>base){
            pR--;
        }
        arr[pL] = arr[pR];
        while(pL<pR&&arr[pL]<=base){
            pL++;
        }
        arr[pR] = arr[pL];
    }
    arr[pL]=base;
    help(arr,L,pL-1);
    help(arr,pL+1,R);
}