快速排序是應用最廣泛的排序演算法，流行的原因是它實現簡單，適用於各種不同情況的輸入資料且在一般情況下比其他排序都快得多。

　　快速排序是原地排序（只需要一個很小的輔助棧），將長度為 N 的陣列排序所需的時間和 N lg N 成正比。

　　1.演算法

　　快速排序也是一種分治的排序演算法。它將一個數組分成兩個子陣列，將兩部分獨立地排序。

　　快速排序和歸併排序是互補：歸併排序是將陣列分成兩個子陣列分別排序，並將有序陣列歸併，這樣陣列就是有序的了；而快速排序將陣列通過切分變成部分有序陣列，然後拆成成兩個子陣列，當兩個子陣列都有序時整個陣列也就有序了。

　　歸併排序的遞迴呼叫發生在處理陣列之前，快速排序的遞迴呼叫是發生在處理陣列之後。

　　快速排序中切分的位置取決於陣列的內容。

    public class Quick: BaseSort
    {
        public new static long usedTimes = 0;
        public static void Sort(IComparable[] a)
        {
            usedTimes = 0;
            Stopwatch timer = new Stopwatch();
            timer.Start();
            Sort(a,0,a.Length-1
 
);
            timer.Stop();
            usedTimes = timer.ElapsedMilliseconds;
        }

        public static void Sort(IComparable[] a, int lo, int hi)
        {
            if (hi <= lo)
                return;

            //切分
            int j = Partition(a,lo,hi);
            //Console.WriteLine(j);
 

            Sort(a,lo,j-1);
            Sort(a,j+1,hi);
        }
        public static int CompareCount = 0;
        public static int Partition(IComparable[] a, int lo, int hi)
        {
            int i = lo;
            int j = hi + 1;
            var v = a[lo];

            while (true)
            {
                //從左往右依次和 v 比較，直到找到 >= v 的值 索引i （索引i 左邊的值都小於切分元素）
                while (Less(a[++i], v))
                {
                    CompareCount++;
                    if (i == hi)
                        break;
                }

                //從右往左依次和 v 比較，直到找到 <= v 的值 索引j（索引j 右邊的值都大於於切分元素）
                while (Less(v, a[--j]))
                {
                    CompareCount++;
                    if (j == lo)
                        break;
                }

                
                //當 i >= j 時就找到了切分元素位置，位置為 j ,退出迴圈
                if (i >= j)
                    break;
                //如果 i 和 j 沒有相遇，將 i 和 j 的值交換，繼續迴圈，直到相遇
                Exch(a,i,j);
            }

            //將切分元素放到切分位置 j 
            Exch(a,lo,j);
            return j;
        }

    }

　　該演算法的關鍵在於切分 ，在Sort(IComparable[] a, int lo, int hi) 方法中，切分後 a[lo] 到 a[j-1] 中的所有元素都不大於 a[ j ] ，a[j+1] 到 a[ hi ] 中的所有元素都不小於 a[ j ] ，然後對左子陣列和右子陣列進行遞迴。因為切分的過程總能排定一個元素，當切分到剩一個元素時，子陣列就是有序的。當左陣列和右陣列都有序時，整個陣列也就有序了。

　　切分方法：先隨意取 a[ lo ] 作為切分元素，即那個將被排定的元素。然後從陣列的左端向右掃描直到找到大於等於它的元素，再從陣列右端向左開始掃描直到找到小於等於它的元素。如果找到的這兩個元素不是同一個元素（索引不同），那麼這個元素就還沒被排定；如果相同意味著這個元素已被排定。如果沒被排定，就交換這兩個元素，繼續掃描，直到左右索引相遇，即可返回將切分元素和找到的索引位置的元素交換，返回索引 j 。

　　排序實列：

　　注意點

　　1. 原地切分

　　該演算法是原地切分，如果使用輔助陣列需要將切分後的陣列複製回去的額外開銷。

　　2.越界

　　要防止掃描指標跑出陣列邊界。

　　3.保持隨機性

　　該演算法對所有子陣列都是一視同仁的。

　　4.終止迴圈

　　該演算法有三個迴圈都要注意什麼時候終止。

　　5.處理切分元素值有重複的情況

　　該演算法左右掃描都會在遇到相等值時停下來，儘管這樣會不必要的等值交換，但在某些情況下能夠避免演算法的執行時間變為平方級別。

　　6.終止遞迴

　　任何遞迴呼叫都要先考慮什麼時候終止。

　　2.效能

　 快速排序執行時間的增長量級為 NlogN 。

　　快速排序切分方法的內迴圈用一個遞增的索引將陣列元素和一個定值比較，這種迴圈很簡潔。它比歸併排序和希爾排序都快，因為歸併排序和希爾排序在內迴圈中移動元素。

　　快速排序的另一個速度優勢在於它的比較次數很少（如果每次都對半分的話需要 N/2 * logN 次比較）。但是排序效率還是依賴切分陣列的效果，而這依賴於切分元素的值 。切分一個較大的資料組，切分可能發生在任何一個位置。

　　快速排序的最好情況是每次都能將陣列對半分。在這種情況下快速排序所用的比較次數正好滿足分治遞迴的 C(N) = 2C(N/2) + N 公式。2C(N/2) 表示將兩個子陣列排序的成本， N 表示 切分元素和所有陣列元素比較的成本。C(N) ~ N log N 。平均而言切分元素都能落在陣列中間。

　　快速排序在最壞情況下需要 ~ N^2 / 2 次比較，即每次切分總有一個數組是空的（逆序），比較次數為： N + （N-1）+ (N-2) ...+2+1 = (N+1)N/2 。這種情況不僅演算法所需的時間是平方級別的，所需的空間是線性的。

　　快速排序平均需要 ~ 2N lnN 次比較（以及1/6的交換）。歸併排序也可以做到這個量級，但是快速排序移動資料次數少（即交換次數），所以快速排序更快，儘管比較次數比歸併排序多了約 39%。

　　當陣列切分不平衡時（第一次用最小的切分，第二次用第二小的切分...）會倒置一個大陣列需要切分很多次（上面說的逆序），所以非重複陣列需要隨機打亂；當存在大量重複元素時，排序過程會進行很多次交換，重複陣列可以使用稍後提到的三向切分的快速排序。

　　3.改進

　　1.切換到插入排序

　　當將一個大陣列切分成一定小的陣列時使用插入排序給小陣列排序，這樣就不需要繼續遞迴呼叫 Sort() 方法了。

　　將if (hi <= lo)return; 改為

　　　　if（hi <= lo + M）{ Insertion.Sort(a, lo, hi); return;}

　　轉換引數 M 的最佳值和系統相關，5 ~ 15 最佳。

　　2.三取樣切分　　

　　改進快速排序效能的另一個方法是使用子陣列的一小部分元素的中位數來切分陣列。這樣得到的切分更好，但是需要計算中位數。一般取樣大小為3並用大小居中的元素切分最好。

　　3.熵最優排序

　　實際應用中經常會出現大量重複元素的陣列，這會影響快排的效能。例如，一個全部重複的子陣列就不需要排序了，但上面的演算法會繼續切分。三向切分的快速排序可以將有大量重複元素的陣列從線性對數級別提高到線性級別。

　　三向切分是將陣列切分成小於，等於和大於三部分。它從左到右遍歷陣列一次，維護一個指標 lt 使得 a[lo ... lt-1] 中的元素都小於 v（切分元素），一個指標 gt 使得 a[gt+1 ... hi] 中的元素都大於 v ，一個指標 i 使得 a[ lt ... i ] 中元素都等於 v , a[ i ... gt ] 中的元素都還未確定。一開始 lo 和 i 相等：

• a[i]小於v：與a[i]交換a[lt]並增加lt和i
• a[i]大於v：將a[i]與a[gt]交換並減少gt
• a[i]等於v：遞增i

    public class Quick: BaseSort
    {
        public new static long usedTimes = 0;

        //三向切分
        public static void Sort3Way(IComparable[] a)
        {
            usedTimes = 0;
            Stopwatch timer = new Stopwatch();
            timer.Start();
            Sort3Way(a, 0, a.Length - 1);
            timer.Stop();
            usedTimes = timer.ElapsedMilliseconds;
        }
        public static void Sort3Way(IComparable[] a, int lo, int hi)
        {
            if (hi < lo)
                return;
            int lt = lo, i = lo + 1, gt = hi;
            IComparable v = a[lo];
            while (i <= gt)
            {
                int cmp = a[i].CompareTo(v);
                if (cmp < 0)
                    Exch(a, lt++, i++);
                else if (cmp > 0)
                    Exch(a, i, gt--);
                else
                    i++;

            }

            Sort3Way(a,lo,lt-1);
            Sort3Way(a,gt+1,hi);
        }
    }

　　對於若干不同主鍵的隨機陣列，歸併排序的時間複雜度是線性對數的，而三向切分快速排序是線性的。三向切分最壞的情況是所有鍵值都不同。當存在重複主鍵時，效能迴避歸併排序好很多。