快速排序

一、概念

来自百度百科：

快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

二、时间空间复杂度

来自百度百科：

快速排序的一次划分算法从两头交替搜索，直到low和hight重合，因此其时间复杂度是O(n)；而整个快速排序算法的时间复杂度与划分的趟数有关。

理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlog2n)
最坏的情况是，每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表中一个为空表，另一子表的长度为原表的长度-1。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n2)。
为改善最坏情况下的时间性能，可采用其他方法选取中间数。通常采用“三者值取中”方法，即比较H->r[low].key、H->r[high].key与H->r[(low+high)/2].key，取三者中关键字为中值的元素为中间数。
可以证明，快速排序的平均时间复杂度也是O(nlog2n)。因此，该排序方法被认为是目前最好的一种内部排序方法。
从空间性能上看，尽管快速排序只需要一个元素的辅助空间，但快速排序需要一个栈空间来实现递归。最好的情况下，即快速排序的每一趟排序都将元素序列均匀地分割成长度相近的两个子表，所需栈的最大深度为log2(n+1)；但最坏的情况下，栈的最大深度为n。这样，快速排序的空间复杂度为O(log2n)。

三、动态过程演示

一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1;
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5）重复第3、4步，直到i==j；

四、Java源代码实现

package sorts;

public class QuickSort {
    public static int[] quicksort(int a[],int left, int right){

        int pivot = a[left];
        int l = left, r = right;
        while (l<r){
            while (l<r && a[r]>pivot){
                r--;
            }
            while ((l<r)&&(a[l]<pivot)){
                l++;
            }
            if(a[l]==a[r] && l<r){
                l++;
            }else {
                int temp = a[l];
                a[l] = a[r];
                a[r] = temp;
            }
        }
        if(l-1>left){
            a = quicksort(a,left,l-1);
        }
        if(r+1<right){
            a = quicksort(a,r+1,right);
        }
        return a;
    }

    public static void main(String[] args) {
        int a[]={36,14,35,34,50,29,16,8,17,15};
        QuickSort.quicksort(a,0,a.length-1);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }
}