你还记得快速排序吗？

为什么80%的码农都做不了架构师？>>>

写个快速排序看看：

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写，说是编译器没对尾递归这种做过多的优化，所以......

 

 

 

转载于:https://my.oschina.net/u/2277632/blog/1584797