你还记得快速排序吗？

写个快速排序看看：

public static void sort(int[] a, int low, int high)
{
    int i,j,t,temp;
    if(low>high) {
        return;
    }
    temp=a[low]; //基准
    i=low;
    j=high;
    while(i!=j)
    {
        while(a[j]>=temp && i<j)//顺序很重要
        {
            j--;
        }
        while(a[i]<=temp && i<j) {
            i++;
        }
        if(i<j)
        {
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }//再把基准数进行交换  
    a[low]=a[i];
    a[i]=temp;
    sort(a,low,i-1);//递归
    sort(a,i+1,high);
}

快速排序使用分治的思想，经过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另外一部分记录的关键字小，另外一部分比基准点。以后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

准备数据测一下：

int[] array = {12,21,15,16,15,1,36,40,3,9,66,9,34,25,77,7,2,56,-15,56,-3,69};
        System.out.print("待排序：");
        for (int aa:array ) {
            System.out.print(aa + " ");
        }
        System.out.println("");
        int start = 0;
        int end = array.length-1;
        sort(array,start,end);
//        sort2(array,start,end);
        System.out.print("排序完：");
        for (int a:array) {
            System.out.print(a + " ");
        }

排序的结果：

上面的操做是从右往左找到比基准小的，从左往右找到比基准大的，而后交换，最后交换基准位置。

还看到一种操做套路是把基准交换来换去，最后的效果也是同样的。我是以为第一种好一点，没有那么多交换操做

public static void sort2(int[] a, int low, int high){
    int start = low;
    int end = high;
    int key = a[low];


    while(end>start){
        //从后往前比较
        while(end>start&&a[end]>=key)
        {
            end--;
        }
        if(a[end]<key){
            int temp = a[end];
            a[end] = a[start];
            a[start] = temp;
        }
        //从前日后比较
        while(end>start&&a[start]<=key)
        {
            start++;
        }
        if(a[start]>key){
            int temp = a[start];
            a[start] = a[end];
            a[end] = temp;
        }
    }
    //递归
    if(start>low) {
        sort2(a, low, start - 1);
    }
    if(end<high) {
        sort2(a, end + 1, high);
    }
}

这边的选择基准点就是选第一个数据，若是在数据基本有序的状况下，你选择第一个数据是比较糟糕的，因此若是针对的都是这样的数据，那么能够考虑选择随机的位置做为基准点，总不至于那么倒霉吧，固然糟糕的时候仍是糟糕的，你懂我说的糟糕的时间的复杂度。

最佳的划分是将待排序的序列分红等长的子序列，最佳的状态咱们可使用序列的中间的值。咱们但是学过中位数的数，前人们总结了一个随机取三数（随机也能够直接取左边，右边，和中间，由于反正数据是随机的，再弄一个随机也不必），而后取中位数做为基准，至少避开了那种最倒霉的状况哈哈。咱们这边只是取了三个数，若是加大样本的数据，是方便了和加快了排序，可是前期就花了很多时间，具体仍是要根据排序数据规模来处理，并非放之四海皆准。

还有前辈们说对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到必定大小后，继续分割的效率比插入排序要差，此时可使用插排而不是快排。我还不知道怎么分析出来的，可是这样有个地方，看排序的后面有个递归，若是待排序的序列划分极端不平衡，递归的深度将趋近于n，而栈的大小是颇有限的，每次递归调用都会耗费必定的栈空间，函数的参数越多，每次递归耗费的空间也越多。因此这边还能够改为尾递归，优化后，能够缩减堆栈深度，听说能够由原来的O(n)缩减为O(logn)，将会提升性能，可是用java写，说是编译器没对尾递归这种作过多的优化，因此......