<續>快速排序算法的深入分析
來源：
作者:July 二零一一年二月二十七日
出處：http://blog.csdn.net/v_july_v/article/details/6211155
--------------------------
前言
一、快速排序最初的版本
二、Hoare版本的具體分析
三、Hoare變種版本
四、快速排序的優化版本
五、快速排序的深入分析
六、Hoare變種版本與優化後版本的比較
七、快速排序算法的時間複雜度
八、由快速排序所想到的
前言
之前，曾在本BLOG內寫過一篇文章，十二、快速排序算法，不少網友反映此文好懂。然，後來有網友algorithm__，指出，“快速排序算法怎麼一步一步想到的列?就如一個P與NP問題。知道了解，證明不難。可不知道解之前，要一點一點、一步一步推導出來，好難阿?”
其實，這個問題，我也想過很多次了。之前，也曾在博客裏多次提到過。那麼，到底爲什麼，有不少人看了我寫的快速排序算法，過了一段時間後，又不清楚快排是怎麼一回事了列?
以下是我在十、從頭到尾徹底理解傅里葉變換算法、下，一文裏回覆algorithm__的評論：
“很大一部分原因，就是隻知其表，不知其裏，只知其用，不知其本質。很多東西，都是可以從本質看本質的。而大部分人沒有做到這一點。從而看了又忘，忘了再看，如此，在對知識的一次一次重複記憶中，始終未能透析本質，從而，形成不好的循環。
所以，歸根究底，學一個東西，不但要運用自如，還要通曉其原理，來龍去脈與本質。正如侯捷先生所言，只知一個東西的用法，卻不知其原理，實在不算高明。你提出的問題，非常好。我會再寫一篇文章，徹底闡述快速排序算法是如何設計的，以及怎麼一步一步來的。”
ok，那麼現在，我就來徹底分析下此快速排序算法，希望能讓讀者真正理解此算法，通曉其來龍去脈，明白其內部原理。本文着重分析快速排序算法的過程來源及其時間複雜度，要了解什麼是快速排序算法，請參考此文：精通八大排序算法系列：一、快速排序算法。
一、快速排序最初的版本
快速排序的算法思想(此時，還不叫做快速排序)最初是由，一個名叫C.A.R.Hoare提出的，他給出的算法思想描述的具體版本，如下：
HOARE-PARTITION(A, p, r)
1 x ← A[p]
2 i ← p - 1
3 j ← r + 1
4 while TRUE
5 do repeat j ← j - 1
6 until A[j] ≤ x
7 repeat i ← i + 1
8 until A[i] ≥ x
9 if i < j
10 then exchange A[i] ↔ A[j]
11 else return j
後來，此版本又有不少的類似變種。下面，會具體分析。
二、Hoare版本的具體分析
Hoare在算法導論第7章最後的思考題7-1有所闡述。
在上面，我們已經知道，Hoare的快速排序版本可以通過前後倆個指針，分別指向首尾，分別比較而進行排序。
下面，分析一下此版本：
I、 倆個指針，i指向序列的首部，j指着尾部，即i=1，j=n，取數組中第一個元素ki爲主元，即key<-ki(賦值)。
II、賦值操作（注，以下“->”，表示的是賦值）：
j(找小)，從右至左，不斷--，直到遇到第一個比key小的元素kj，ki<-kj。
i(找大)，從左至右，不斷++，直到遇到第一個比key大的元素ki，kj<-ki。
III、按上述方式不斷進行，直到i，j碰頭，ki=key，第一趟排序完成接下來重複II步驟，遞歸進行。
當過程HOARE-PARTITION結束後，A[p..j](此處在算法導論中文版第二版中出現了印刷錯誤，被印成了A[p..r])中的每個元素都小於或等於A[j+1..r]每一個元素。HOARE-PARTITION與下文將要介紹的標準PARTITION劃分方法不同，HOARE-PARTITION總是將主元值放入兩個劃分A[p..j]和A[j+1..r]中的某一個之中。因爲p<<j<<r，故這種劃分總是會結束的。
接下來，咱們來看下上述HOARE-PARTITION劃分方法在數組A=[13，19,9,5,12,8,7,4,11,2,6,21]上的運行過程，如下：
i（找大） （找小）j
1319 9 5 12 87 4 11 2 621
i j
13
19 9 512
8 7
4 112
621
i j
6 199
5 12
8 74
11 2
13 21
j i
6 29
5 12
8 74
1119
13 21
i j
62
9 5
12 87
411
1913
21
i j
42
95
128
7 6 11
19 1321
ij
4259
128
7 6 11
19 1321
.....
2456
78
9 11 12
13 19
21
三、Hoare變種版本
I、取倆個指針i，j，開始時，i=2，j=n，且我們確定，最終完成排序時，左邊子序列的數<=右邊子序列。
II、矯正位置，不斷交換
i-->(i從左至右，右移，找比第一個元素要大的)
通過比較ki與k1，如果Ri在分劃之後最終要成爲左邊子序列的一部分，
則i++，且不斷i++，直到遇到一個該屬於右邊子序列Ri(較大)爲止。
<--j(j從右至左，左移，找比第一個元素要小的)
類似的，j--，直到遇到一個該屬於左邊子序列的較小元素Rj(較小)爲止，
如此，當i<j時，交換Ri與Rj，即擺正位置麻，把較小的放左邊，較大的放右邊。
III、然後以同樣的方式處理劃分的記錄，直到i與j碰頭爲止。這樣，不斷的通過交換Ri，Rj擺正位置，最終完成整個序列的排序。
舉個例子，如下(2爲主元)：
i-> <-j(找小)
2 8 7 1 3 5 6 4
j所指元素4，大於2，所以，j--，
i <--j
2 8 7 1 3 5 6 4
此過程中，若j 沒有遇到比2小的元素，則j 不斷--，直到j 指向了1，
i j
2 8 7 1 3 5 6 4
此刻，8與1互換，
i j
2 1 7 8 3 5 6 4
此刻，i 所指元素1，小於2，所以i不動，，j 繼續--，始終沒有遇到再比2小的元素，最終停至7。
i j
2 1 7 8 3 5 6 4
最後，i 所指元素1，與數列中第一個元素k1，即2交換，
i
[1] 2 [7 8 3 5 6 4]
這樣，2就把整個序列，排成了2個部分，接下來，再對剩餘待排序的數遞歸進行第二趟、第三趟排序....。
由以上的過程，還是可以大致看出此算法的拙陋之處的。如一，在上述第一步過程中，j沒有找到比2小的元素時，需不斷的前移，j--。二，當i所指元素交換後，無法確保此刻i所指的元素就一定小於2，即i指針，還有可能繼續停留在原處，不能移動。如此停留，勢必應該會耗費不少時間。
後來，進一步，sedgewick因其排序速率較快，便稱之爲"快速排序"，快速排序也因此而誕生了。並最終一舉成名，成爲了二十世紀最偉大的10大算法之一。
OK，接下來，咱們來看Hoare的變種版本算法。如下，對序列3 8 7 1 2 5 6 4，進行排序：
1、j--，直到遇到了序列中第一個比key值3小的元素2，把2賦給ki，j 此刻指向了空元素。
i j
3 8 7 1 2 5 6 4
i j
=> 2 8 7 1 5 6 4
2、i++，指向8，把8重置給j 所指元素空白處，i 所指元素又爲空：
i j
2 8 7 1 5 6 4
i j
=> 2 7 1 8 5 6 4
3、j繼續--，遇到了1，還是比3(事先保存的key值)小，1賦給i所指空白處：
i j
2 7 1 8 5 6 4
=> 2 1 7 8 5 6 4
4、同理，i 又繼續++，遇到了7，比key大，7賦給j所指空白處，此後，i，j碰頭。第一趟結束：
i j
2 1 7 8 5 6 4
i j
=> 2 1 7 8 5 6 4
5、最後，事先保存的key，即3賦給ki，即i所指空白處，得：
[2 1] 3 [7 8 5 6 4]
所以，整趟下來，便是這樣：
3 8 7 1 2 5 6 4
2 8 7 1 3 5 6 4
2 3 7 1 8 5 6 4
2 1 7 3 8 5 6 4
2 1 3 7 8 5 6 4
2 1 3 7 8 5 6 4
後續補充：
如果待排序的序列是逆序數列列?ok，爲了說明的在清楚點，再舉個例子，對序列 9 8 7 6 5 4 3 2 1排序：
9 8 7 6 5 4 3 2 1 //9爲主元
1 8 7 6 5 4 3 2 //j從右向左找小，找到1，賦給第一個
1 8 7 6 5 4 3 2 //i從左向右找大，沒有找到，直到與j碰頭
1 8 7 6 5 4 3 2 9 //最後，填上9.
如上，當數組已經是逆序排列好的話，我們很容易就能知道，此時數組排序需要O(N^2)的時間複雜度。稍後下文，會具體分析快速排序的時間複雜度。
最後，寫程序實現此算法，如下，相信，不用我過多解釋了：
int partition(int data[],int lo,int hi) //引自whatever。
{
int key=data[lo];
int l=lo;
int h=hi;
while(l<h)
{
while(key<=data[h] && l<h) h--; //高位找小，找到了，就把它弄到前面去
data[l]=data[h];
while(data[l]<=key && l<h) l++; //低位找大，找到了，就把它弄到後面去
data[h]=data[l];
} //如此，小的在前，大的在後，一分爲二
data[l]=key;
return l;
}
後續補充：舉個例子，如下（只說明了第一趟排序）：
3 8 7 1 2 5 6 4
2 8 7 1 5 6 4
2 7 1 8 5 6 4
2 1 7 8 5 6 4
2 1 7 8 5 6 4
2 1 3 7 8 5 6 4 //最後補上，關鍵字3
看到這，不知各位讀者，有沒有想到我上一篇文章裏頭，一、快速排序算法，的那快速排序的第二個版本?對，上述程序，即那篇文章裏頭的第二個版本。我把程序揪出來，你一看，就明白了：
void quicksort(table *tab,int left,int right)
{
int i,j;
if(left<right)
{
i=left;j=right;
tab->r[0]=tab->r[i]; //準備以本次最左邊的元素值爲標準進行劃分，先保存其值
do
{
while(tab->r[j].key>tab->r[0].key&&i<j)
j--; //從右向左找第1個小於標準值的位置j
if(i<j) //找到了，位置爲j
{
tab->r[i].key=tab->r[j].key;i++;
} //將第j個元素置於左端並重置i
while(tab->r[i].key<tab->r[0].key&&i<j)
i++; //從左向右找第1個大於標準值的位置i
if(i<j) //找到了，位置爲i
{
tab->r[j].key=tab->r[i].key;j--;
} //將第i個元素置於右端並重置j
}while(i!=j);
tab->r[i]=tab->r[0]; //將標準值放入它的最終位置,本次劃分結束
quicksort(tab,left,i-1); //對標準值左半部遞歸調用本函數
quicksort(tab,i+1,right); //對標準值右半部遞歸調用本函數
}
}
我想，至此，已經講的足夠明白了。如果，你還不懂的話，好吧，伸出你的手指，數數吧....ok，再問讀者一個問題：像這種i從左至右找大，找到第一個比key大(數組中第一個元素置爲key)，便重置kj，j從右向左找小，找到第一個比key小的元素，則重置ki，當然此過程中，i，j都在不斷的變化，通過++，或--，指向着不同的元素。
你是否聯想到了，現實生活中，有什麼樣的情形，與此快速排序算法思想相似?ok，等你想到了，再告訴我，亦不遲。:D。
四、快速排序的優化版本
再到後來，N.Lomuto又提出了一種新的版本，此版本即爲此文快速排序算法，中闡述的第一個版本，即優化了PARTITION程序，它現在寫在了 算法導論 一書上，
快速排序算法的關鍵是PARTITION過程，它對A[p..r]進行就地重排：
PARTITION(A, p, r)
1 x ← A[r] //以最後一個元素，A[r]爲主元
2 i ← p - 1
3 for j ← p to r - 1 //注，j從p指向的是r-1，不是r。
4 do if A[j] ≤ x
5 then i ← i + 1
6 exchange A[i] <-> A[j]
7 exchange A[i + 1] <-> A[r]
8 return i + 1
然後，對整個數組進行遞歸排序：
QUICKSORT(A, p, r)
1 if p < r
2 then q ← PARTITION(A, p, r) //關鍵
3 QUICKSORT(A, p, q - 1)
4 QUICKSORT(A, q + 1, r)
舉最開頭的那個例子：2 8 7 1 3 5 6 4，不過與上不同的是：它不再以第一個元素爲主元，而是以最後一個元素4爲主元，且i，j倆指針都從頭出發，j 一前，i 一後。i 指元素的前一個位置，j 指着待排序數列中的第一個元素。
一、
i p/j-->
2 8 7 1 3 5 6 4(主元)
j 指的2<=4，於是i++，i 也指到2，2和2互換，原數組不變。
j 後移，直到指向1..
二、
j（指向1）<=4，於是i++，i指向了8，
i j
2 8 7 1 3 5 6 4
所以8與1交換，數組變成了：
i j
2 1 7 8 3 5 6 4
三、j 後移，指向了3,3<=4，於是i++
i 這時指向了7，
i j
2 1 7 8 3 5 6 4
於是7與3交換，數組變成了：
i j
2 1 3 8 7 5 6 4
四、j 繼續後移，發現沒有再比4小的數，所以，執行到了最後一步，
即上述PARTITION(A, p, r)代碼部分的 第7行。
因此，i後移一個單位，指向了8
i j
2 1 3 8 7 5 6 4
A[i + 1] <-> A[r]，即8與4交換，所以，數組最終變成了如下形式，
2 1 3 4 7 5 6 8
ok，快速排序第一趟完成。接下來的過程，略，詳細，可參考此文：快速排序算法。不過，有個問題，你能發現此版本與上述版本的優化之處麼?
五、快速排序的深入分析
咱們，再具體分析下上述的優化版本，
PARTITION(A, p, r)
1 x ← A[r]
2 i ← p - 1
3 for j ← p to r - 1
4 do if A[j] ≤ x
5 then i ← i + 1
6 exchange A[i] <-> A[j]
7 exchange A[i + 1] <-> A[r]
8 return i + 1
咱們以下數組進行排序，每一步的變化過程是：
i p/j
2 8 7 1 3 5 6 4(主元)
i j
2 1 7 8 3 5 6 4
i j
2 1 3 8 7 5 6 4
i
2 1 3 4 7 5 6 8
由上述過程，可看出，j掃描了整個數組一遍，只要一旦遇到比4小的元素，i 就++，然後，kj、ki交換。那麼，爲什麼當j找到比4小的元素後，i 要++列? 你想麻，如果i始終停在原地不動，與kj 每次交換的ki不就是同一個元素了麼?如此，還談什麼排序?。
所以，j在前面開路，i跟在j後，j只要遇到比4小的元素，i 就向前前進一步，然後把j找到的比4小的元素，賦給i，然後，j纔再前進。
打個比喻就是，你可以這麼認爲，i所經過的每一步，都必須是比4小的元素，否則，i就不能繼續前行。好比j 是先行者，爲i 開路搭橋，把小的元素作爲跳板放到i 跟前，爲其鋪路前行啊。
於此，j掃描到最後，也已經完全排查出了比4小的元素，只有最後一個主元4，則交給i處理，因爲最後一步，exchange A[i + 1] <-> A[r]。這樣，不但完全確保了只要是比4小的元素，都被交換到了數組的前面，且j之前未處理的比較大的元素則被交換到了後面，而且還是O（N）的時間複雜度，你不得不佩服此算法設計的巧妙。
這樣，我就有一個問題了，上述的PARTITION(A, p, r)版本，可不可以改成這樣咧?
望讀者思考：
PARTITION(A, p, r) //請讀者思考版本。
1 x ← A[r]
2 i ← p - 1
3 for j ← p to r //讓j 從p指向了最後一個元素r
4 do if A[j] ≤ x
5 then i ← i + 1
6 exchange A[i] <-> A[j]
//7 exchange A[i + 1] <-> A[r] 去掉此最後的步驟
8 return i //返回 i，不再返回 i+1.
六、Hoare變種版本與優化後版本的比較
現在，咱們來討論一個問題，快速排序中，其中對於序列的劃分，我們可以看到，已經有以上倆個版本，那麼這倆個版本孰優孰劣列?ok，不急，咱們來比較下：
爲了看着方便，再貼一下各自的算法，
Hoare變種版本：
HOARE-PARTITION(A, p, r)
1 x ← A[p] //以第一個元素爲主元
2 i ← p - 1
3 j ← r + 1
4 while TRUE
5 do repeat j ← j - 1
6 until A[j] ≤ x
7 repeat i ← i + 1
8 until A[i] ≥ x
9 if i < j
10 then exchange A[i] ↔ A[j]
11 else return j
優化後的算法導論上的版本：
PARTITION(A, p, r)
1 x ← A[r] //以最後一個元素，A[r]爲主元
2 i ← p - 1
3 for j ← p to r - 1
4 do if A[j] ≤ x
5 then i ← i + 1
6 exchange A[i] <-> A[j]
7 exchange A[i + 1] <-> A[r]
8 return i + 1
咱們，先舉上述說明Hoare版本的這個例子，對序列3 8 7 1 2 5 6 4，進行排序：
Hoare變種版本（以3爲主元，紅體爲主元）：
3 8 7 1 2 5 6 4
2 8 7 1 5 6 4 //交換1次，比較4次
2 7 1 8 5 6 4 //交換1次，比較1次
2 1 7 8 5 6 4 //交換1次，比較1次
2 1 7 8 5 6 4 //交換1次，比較0次
2 1 3 7 8 5 6 4 //總計交換4次，比較6次。
//移動了元素3、8、7、1、2.移動範圍爲：2+3+1+2+4=12.
優化版本（以4爲主元）：
3 8 7 1 2 5 6 4 //3與3交換，不用移動元素，比較1次
3 1 7 8 2 5 6 4 //交換1次，比較3次
3 1 2 8 7 5 6 4 //交換1次，比較1次
3 1 2 4 7 5 6 8 //交換1次，比較2次。
//即完成，總計交換4次，比較7次。
//移動了元素8、7、1、2、4.移動範圍爲：6+2+2+2+4=16.
再舉一個例子：對序列2 8 7 1 3 5 6 4排序：
Hoare變種版本：
2 8 7 1 3 5 6 4
1 8 7 3 5 6 4 //交換1次，比較5次
1 7 8 3 5 6 4 //交換1次，比較1次
1 2 7 8 3 5 6 4 //交換0次，比較1次。2填上，完成，總計交換2次，比較7次。
優化版本：
2 8 7 1 3 5 6 4 //2與2交換，比較1次
2 1 7 8 3 5 6 4 //交換1次，比較3次
2 1 3 8 7 5 6 4 //交換1次，比較1次
2 1 3 4 7 5 6 8 //交換1次，比較2次。完成，總計交換4次，比較7次。
各位，已經看出來了，這倆個例子說明不了任何問題。到底哪個版本效率更高，還有待進一步驗證或者數學證明。ok，等我日後發現更有利的證據再來論證下。
七、快速排序算法的時間複雜度
ok，我想你已經完全理解了此快速排序，那麼，我想你應該也能很快的判斷出：快速排序算法的平均時間複雜度，即爲O(nlgn)。爲什麼列?因爲你看，j，i掃描一遍數組，花費用時多少?對了，掃描一遍，當然是O(n)了，那樣，掃描多少遍列，lgn到n遍，最快lgn，最慢n遍。且可證得，快速排序的平均時間複雜度即爲O(n*lgn)。
PARTITION可能做的最平衡的劃分中，得到的每個子問題都不能大於n/2.
因爲其中一個子問題的大小爲|_n/2_|。另一個子問題的大小爲|-n/2-|-1.
在這種情況下，快速排序的速度要快得多。爲：
T(n)<=2T（n/2）+O（n）.可以證得，T（n）=O（nlgn）。
以下給出一個遞歸樹的簡單證明：
在分治算法中的三個步驟中， 我們假設分解和合並過程所用的時間分別爲D(n), C(n), 設T(n)爲處理一個規模爲n的序列所消耗的時間爲子序列個數，每一個子序列是原序列的1/b，α爲把每個問題分解成α個子問題, 則所消耗的時間爲：
O（1） 如果n<=c
T(n) =
αT(n/b) + D(n) + C(n)
在快速排序中,α 是爲2的, b也爲2, 則分解(就是取參照點,可以認爲是1), 合併(把數組合並,爲n), 因此D(n) + C(n) 是一個線性時間O(n).這樣時間就變成了：
T(n) = 2T(n/2) + O(n).
如上圖所示，在每個層的時間複雜度爲: O(n)，一共有Lgn層,每一層上都是cn, 所以共消耗時間爲cn*lgn; 則總時間:
cn*lg2n+cn = cn(1+lgn) 即O(nlgn)。
關於T(n)<=2T（n/2）+O（n）=>T（n）=O（nlgn）的嚴格數學證明，可參考算法導論 第四章 遞歸式。
而後，我想問讀者一個問題，由此快速排序算法的時間複雜度，你想到了什麼，是否想到了歸併排序的時間複雜度，是否想到了二分查找，是否想到了一課n個結點的紅黑樹的高度lgn，是否想到了......
八、由快速排序所想到的
上述提到的東西，很早以前就想過了。此刻，我倒是想到了前幾天看到的一個荷蘭國旗問題。當時，和algorithm__、gnuhpc簡單討論過這個問題。現在，我也來具體解決下此問題：
問題描述：
我們將亂序的紅白藍三色小球排列成有序的紅白藍三色的同顏色在一起的小球組。這個問題之所以叫荷蘭國旗，是因爲我們可以將紅白藍三色小球想象成條狀物，有序排列後正好組成荷蘭國旗。如下圖所示：
這個問題，類似快排中partition過程。不過，要用三個指針，一前begin，一中current，一後end，倆倆交換。
1、current遍歷，整個數組序列，current指1不動，
2、current指0，與begin交換，而後current++，begin++，
3、current指2，與end交換，而後，current不動，end--。
爲什麼，第三步，current指2，與end交換之後，current不動了列，對的，正如algorithm__所說：current之所以與begin交換後，current++、begin++，是因爲此無後顧之憂。而current與end交換後，current不動，end--，是因有後顧之憂。
爲什麼啊，因爲你想想啊，你最終的目的無非就是爲了讓0、1、2有序排列，試想，如果第三步，current與end交換之前，萬一end之前指的是0，而current交換之後，current此刻指的是0了，此時，current能動麼？不能動啊，指的是0，還得與begin交換列。
ok，說這麼多，你可能不甚明瞭，直接引用下gnuhpc的圖，就一目瞭然了：
本程序主體的代碼是：
//引用自gnuhpc
while( current<=end )
{
if( array[current] ==0 )
{
swap(array[current],array[begin]);
current++;
begin++;
}
else if( array[current] == 1 )
{
current++;
}
else //When array[current] =2
{
swap(array[current],array[end]);
end--;
}
}
看似，此問題與本文關係不大，但是，一來因其餘本文中快速排序partition的過程類似，二來因爲此問題引發了一段小小的思考，並最終成就了本文。差點忘了，還沒回答本文開頭提出的問題。所以，快速排序算法是如何想到的，如何一步一步發明的列?答案很簡單：多觀察，多思考。
ok，測試一下，看看你平時有沒有多觀察、多思考的習慣：我不知道是否有人真正思考過冒泡排序，如果思考過了，你是否想過，怎樣改進冒泡排序列?ok，其它的，我就不多說了，只貼以下這張圖：
