数据结构---分治排序（大数据，log复杂度）

//归并，按中间分开，往下分，一直分到只有一个终止。分开了的，前后比对，小的入列；每一层做的事情一样，又有终止条件；递，归；
    //老的衡量标准：稳定不。看每一层排序是否以左边为主，是就是稳定。在前面的始终在墙面
    //时间复杂读，当n=1;T(n)=o(1);当n>1;
    //T(n)=2*T(n/2)(按中间分割两部分消耗)+n(merge方法消耗);
    //T(n)=2(2*T(n/（2*2）)+n/2)+n;=4*T(n/4)+2n;再往下一层，用n/2的量往下一层；
    //往下推，必然T(n)=2k*T(n/2k)+kn;不断往下分割，递归的终极条件是n/2k=1,也就是n=2k;也就是k=log2n就露出尾部了。
    //T(n)=2log2n*o(1)+nlog2n;故T(n)=nlogn;
    //空间复杂读，原地排序否，肯定不是，额外空间复杂度O(n),单线程方法顺序执行，仅有一个临时内存空间
    //前面冒泡（两两排序），插入（前面拍好，后面还没拍，最靠近的拿去跟前面的排），选择(也是前后，但是选择最佳的在后面接起来)，
    public void sort(int[] target,int start,int end){
        if(start >= end) return;
        sort(target,start,(start+end)/2);
        sort(target,(start+end)/2+1,end);
        merge(target,start,end);            
    }
    
    public void merge(int[]target,int start,int end){
        int[] temp = new int[end+1];
        int leftStart = start;
        int rightStart = (start+end)/2+1;
        for(int i=start;i<=end;i++){
            if(leftStart <= (start+end)/2 && rightStart <= end){
                if(target[leftStart] >= target[rightStart]){
                    temp[i] = target[rightStart];
                    rightStart++;
                }else{
                    temp[i] = target[leftStart];
                    leftStart++;
                }
                continue;
            }
            if(leftStart <=(start+end)/2){
                temp[i] = target[leftStart];
                leftStart++;
            }
            if(rightStart <= end){
                temp[i] = target[rightStart];
                rightStart ++;
            }
        }
        for(int i=start;i<=end;i++){
            target[i] = temp[i];
        }
    }
    
    
    public static void main(String[] args) throws Exception {
        int[] target = {454,43,54,45345,54,433,54,54,4333,454665,88,545,4534327};
        
        new test().sort(target, 0, target.length-1);
        for(int i:target){
            System.out.print(i+" ");            
        }

    }

 

//快速排序：以其中一个数作为分区的标准（默认取最后面一个），比标准大的放左边，比标准小的放右边；
    //时间复杂度：人和情况下，nlogn，不人道n平方
    //空间复杂度：原地
    //稳定否（3，3是否保持原有位置，多级梯度情况下是否阔以）：不一定，就选中那家伙不知道靠谱不
    public void quickSort(int[] target,int start,int end){
        if(start >= end){
            return;
        }
        int i = partition(target,start,end);
        quickSort(target,start,i);
        quickSort(target,i+1,end);
    }
    
    public int partition(int[] target,int start,int end){
        int i=start;
        int j=start;
        for(;j             if(target[j]                 int temp = target[j];
                target[j] = target[i];
                target[i] = temp;
                i++;
            }
        }
        if(i             int temp = target[end];
            target[end] = target[i];
            target[i] = temp;            
        }else if (i == end){
            return i-1;
        }

        return i;
    }
    
    public static void main(String[] args) throws Exception {
        
        int[] target = {45,787,88,4343,232,5645,45};
        new test().quickSort(target, 0, target.length-1);
        for(int i:target){
            System.out.println(i + "  ");            
        }