JAVA數據結構--快速排序

快排概念

快速排序（英語：Quicksort），又稱划分交換排序（partition-exchange sort），一種排序算法，最早由東尼·霍爾提出。在平均狀況下，排序個項目要（大O符號）次比較。在最壞狀況下則需要次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

實現思想

快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。

步驟為：

1. 從數列中挑出一個元素，稱為"基准"（pivot），
2. 重新排序數列，所有比基准值小的元素擺放在基准前面，所有比基准值大的元素擺在基准后面（相同的數可以到任何一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
3. 遞歸地（recursively）把小於基准值元素的子數列和大於基准值元素的子數列排序。

遞歸到最底部時，數列的大小是零或一，也就是已經排序好了。這個算法一定會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

借用下啊哈算法的圖：

i和j分別為左哨兵和右哨兵，這里樞紐元定為6，然后分別從左往右（i++）和右往左（j--）開始遍歷

左哨兵查找比6大的元素，右哨兵查找比6小的元素

第一次交換結果

 

第二次交換結果

 

相遇后直接與樞紐元交換

然后再遞歸排序就行

 

---

快排核心算法代碼

public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
        /*
         * 當數組不小於3時，才推薦使用快排
         * */
        if(left+CUTOFF<=right)
        {
            //取出樞紐元，樞紐元的位置為right-1
            T privot=median3(a, left, right);
            
            int i=left,j=right-1;
            for(;;)
            {
                while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍歷
                while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍歷
                if(i<j)
                    swapReferences(a, i, j);
                else
                    break;
            }
            /*
             * for循環終止條件為i和j相遇，此時再將樞紐元歸位
             * */
            swapReferences(a, i, right-1);
            
            quicksort(a, left, i-1);//對左半部進行遞歸
            quicksort(a, i+1, right);//對右半部進行遞歸
        }
        else
        {}
    }

全部代碼實現

public class MyQuickSort {
    private static final int CUTOFF=3;
    public static <T extends Comparable<? super T>> void quicksort(T[] a) {
        quicksort(a,0,a.length-1);
    }
    public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
        /*
         * 當數組不小於3時，才推薦使用快排
         * */
        if(left+CUTOFF<=right)
        {
            //取出樞紐元，樞紐元的位置為right-1
            T privot=median3(a, left, right);
            
            int i=left,j=right-1;
            for(;;)
            {
                while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍歷
                while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍歷
                if(i<j)
                    swapReferences(a, i, j);
                else
                    break;
            }
            /*
             * for循環終止條件為i和j相遇，此時再將樞紐元歸位
             * */
            swapReferences(a, i, right-1);
            
            quicksort(a, left, i-1);//對左半部進行遞歸
            quicksort(a, i+1, right);//對右半部進行遞歸
        }
        else
        {}
    }
    /*
     * 數組中數值交換
     * */
    public static <T> void swapReferences(T[] a,int index1,int index2) {
        T tmp=a[index1];
        a[index1]=a[index2];
        a[index2]=tmp;
    }
    /*
     * 確定樞紐元，樞紐元的位置放在right-1位置
     * */
    private static <T extends Comparable<? super T>> T median3(T[] a,int left,int right) {
        int center=(left+right)/2;
        if(a[center].compareTo(a[left])<0)
            swapReferences(a, left, center);
        if(a[right].compareTo(a[center])<0)
            swapReferences(a, center, right);
        if(a[right].compareTo(a[left])<0)
            swapReferences(a, left, right);
        
        swapReferences(a, center, right-1);
        return a[right-1];
    }
}