一、選取最後一個元素

在我們的課本中，看到最多的就是選擇第一個元素作為中軸，但是在很多書上卻選擇最後一個元素作為中軸。下面就讓我們來一睹選取最後一個元素作為中軸的快排。

注：本文中的所有演算法都採用雙向掃描法，即，設兩個下標i和j，i和右掃描，j向左掃描，直到i不小於j。而當下標為i的數小於中軸時，跳過並繼續向右掃描，否則停止掃描，並開始j的向左掃描，相對地，當下標為j的數大於中軸時，跳過並繼續向右掃描，否則停止掃描，然後交換下標為i和j的兩個數，並從下一個位置繼續兩個方向的掃描，直到i不小於j。最後把中軸與下標為i的元素交換即完成一趟的快排。

下面就以最後一個元素作為中軸來說明。

初始資料為： 8  1  4  9  0  3  5  2  7  6
中軸為：6，第一趟快排的情景如下：

8  1  4  9  0  3  5  2  7  6

↑                               ↑

i→                         ←j
 第一次交換後：
 2  1  4  9  0  3  5  8  7  6
 ↑                          ↑
 i                            j

第二次交換後：
2  1  4  5  0  3  9  8  7  6
            ↑          ↑
            i           j
第三次交換前：
2  1  4  5  0  3  9  8  7  6
                    ↑  ↑
                     j   i

選取最後一個元素作為中軸的好處是簡單直觀，操作一致。因為我們通常把下標為i的元素與中軸元素作為交換，而i則總是指向比中軸大的元素，而把大的元素放到後面總是合理的。

二、雙向描述法中的越界問題

快速排序中都非常喜歡使用雙向掃描法，然而這個方法卻存在一個越界問題，考慮如下的情況：
          8  1  4  6  9  3  5  2  7  0
           i→                        ←j

當我們選取最後一個元素作為中軸時，j向左掃描，一直到找到一個比0小的數，但是它卻是陣列中的最小值，所以j會一直向左走，直到越界。

這個問題無論是使用第一個元素作為中軸，還是使用最後一個元素作為中軸都會存在。所以，在雙向描述中，必然有一個方向（遠離中軸的方法）要做越界檢查。

選取最後一個元素作為中軸的快排的關鍵程式碼

1. void QSort(DataType *data, int left, int right)  
2. {  
3.     //如果資料的個小數為1或0則不需要排序
4.     if(left >= right)  
5.         return;  
6.     //取最後一個元素作為樞紐
7.     DataType centre = data[right];  
8.     int i = left;  
9.     int j = right-1;  
10.     while(true)  
11.     {  
12.         //從前向後掃描，找到第一個小於樞紐的值，
13.         //在到達陣列末尾前，必定結果迴圈,因為最後一個值為centre
14.         while(data[i] < centre)  
15.             ++i;  
16.         //從後向前掃描，此時要檢查下標，防止陣列越界
17.         while(j >= left && data[j] > centre)  
18.             --j;  
19.         //如果沒有完成一趟交換，則交換
20.         if(i < j)  
21.             Swap(data[i++], data[j--]);  
22.         else
23.             break;  
24.     }  
25.     //把樞紐放在正確的位置
26.     Swap(data[i], data[right]);  
27.     QSort(data, left, i - 1);  
28.     QSort(data, i + 1, right);  
29. }  

三、隨機選元法

我們知道，在快排中，中軸的選擇對於演算法的效率是非常重要的，選擇一個好的中軸選擇策略會使演算法的效率顯著提高。

無論是前面說的選取第一個元素還是最後一個元素作為中軸，其實都是一個壞的選元方法。因為當元素基本有序時，這兩種方法都會使演算法的效率非常低，最壞情況下，是O(n^2)。

隨機選元法的思路：使用隨機數生成函式生成一個隨機數rand，隨機數的範圍為[left, right]，並用此隨機數為下標對應的元素a[rand]作為中軸，並與最後一個元素a[right]交換，然後進行與選取最後一個元素作為中軸的快排一樣的演算法即可。

隨機選元法仍然存在掃描越界問題，所以在遠離中軸的方法上仍然需要檢查下標。

隨機選元法的關鍵程式碼

1. void QSort(DataType *data, int left, int right)  
2. {  
3.     //如果資料的個小數為1或0則不需要排序
4.     if(left >= right)  
5.         return;  
6.     //隨機選取一個元素作為樞紐，並與最後一個元素交換
7.     int ic = Random(left, right);  
8.     Swap(data[ic], data[right]);  
9.     DataType centre = data[right];  
10.     int i = left;  
11.     int j = right-1;  
12.     while(true)  
13.     {  
14.         //從前向後掃描，找到第一個小於樞紐的值，
15.         //在到達陣列末尾前，必定結果迴圈,因為最後一個值為centre
16.         while(data[i] < centre)  
17.             ++i;  
18.         //從後向前掃描，此時要檢查下標，防止陣列越界
19.         while(j >= left && data[j] > centre)  
20.             --j;  
21.         //如果沒有完成一趟交換，則交換
22.         if(i < j)  
23.             Swap(data[i++], data[j--]);  
24.         else
25.             break;  
26.     }  
27.     //把樞紐放在正確的位置
28.     Swap(data[i], data[right]);  
29.     QSort(data, left, i - 1);  
30.     QSort(data, i + 1, right);  
31. }  
32. inlineint Random(int begin, int end)  
33. {  
34.     //產生begin至end，包括begin和end的隨機數，即[begin, end]範圍的整數
35.     return rand()%(end - begin + 1) + begin;  
36. }  

從上面的程式碼也可以看出，隨機選法與選取最後一個元素作為中軸的方法是非常相近的，只是多了把隨機的中軸放到最後的位置的操作。

四、三數中值分割法

一組N個數的中值是第N/2個最大數，中軸的最好選擇就是陣列的中值。不幸的是，這很難算出。但這樣的中值的估計量可以通過隨機選取三個元素並用它們的中值作為中軸而得到。事實上，隨機性並沒有多大的幫助，因此一般的做法是使用左端、右端和中心位置上的三個元素的中值作為中軸。

分割策略：假設陣列被排序的範圍為left和right，center=（left+right）/2，對a[left]、a[right]和a[center]進行適當排序，取中值為中軸，將最小者放a[left]，最大者放在a[right]，把中軸元與a[right-1]交換，並在分割階段將i和j初始化為left+1和right-2。然後使用雙向描述法，進行快排。

三數中值分割法的實現

初始資料：                    6  1  8  9  4  3  5  2  7  0
對三個數進行排序後：  0  1  8  9  4  3  5  2  7  6
中軸與a[right-1]交換：  0  1  8  9  7  3  5  2  4  6
開始掃描：                         i→               ←j
第一次交換後：            0  1  2  9  7  3  5  8  4  6
                                              i =2              j=7
第二次交換後：            0  1  2  3  7  9  5  8  4  6
                                                  i=3   j=5
第三次交換前：            0  1  2  3  7  9  5  8  4  6
  i=4,j= 3                                3=j   i=4
第三次交換後：            0  1  2  3  4  9  5  8  7  6 
     (與a[right-1]交換) 

分割策略的好處

1）將三元素中最小者被分到a[left]、最大者分到a[right]是正確的，因為當快排一趟後，比中軸小的放到左邊，而比中軸大的放到右邊，這樣就在分割的時候把它們分到了正確的位置，減少了一次比較和交換。
2）在前面所說的所有演算法中，都有雙向掃描時的越界問題，而使用這個分割策略則可以解決這個問題。因為i向右掃描時，必然會遇到不小於中軸的數a[right-1]，而j在向左掃描時，必然會遇到不大於中軸的數a[left]，這樣，a[right-1]和a[left]提供了一個警戒標記，所以不需要檢查下標越界的問題。

關鍵實現程式碼

1. DataType Median3(DataType *data, int left, int right)  
2. {  
3.     //取資料的頭、尾和中間三個數，並對他們進行排序
4.     //排序結果直接儲存在陣列中
5.     int centre = (left + right)/2;  
6.     if(data[left] > data[centre])  
7.         Swap(data[left], data[centre]);  
8.     if(data[left] > data[right])  
9.         Swap(data[left], data[right]);  
10.     if(data[centre] > data[right])  
11.         Swap(data[centre], data[right]);  
12.     //把中值，即樞紐與陣列倒數第二個元素交換
13.     swap(data[centre], data[right - 1]);  
14.     return data[right - 1];//返回樞紐
15. }  
16. void QSort(DataType *data, int left, int right)  
17. {  
18.     //如果需要排序的資料大於3個則使用快速排序
19.     if(right - left >= 3)  
20.     {  
21.         //取得樞紐的值
22.         DataType centre = Median3(data, left, right);  
23.         int begin = left;  
24.         int end = right - 1;  
25.         while(true)  
26.         {  
27.             //向後掃描陣列
28.             //由於在選擇樞紐時，已經把比樞紐值大的資料放在right位置
29.             //所以不會越界
30.             while(data[++begin] < centre);  
31.             //向前掃描陣列
32.             //由於在選擇樞紐時，已經把比樞紐值小的資料放在left位置
33.             //所以不會越界
34.             while(data[--end] > centre);  
35.             //把比樞紐小的資料放在前部，大的放到後部
36.             if(begin < end)  
37.                 Swap(data[begin], data[end]);  
38.             else
39.             {  
40.                 //已經對要排序的資料都與樞紐比較了一次
41.                 //把中樞紐儲存在適當的位置，因為begin的數一定比樞紐大
42.                 //所以把這個數放在陣列後面
43.                 Swap(data[begin], data[right - 1]);  
44.                 break;  
45.             }  
46.         }  
47.         QSort(data, left, begin - 1);  
48.         QSort(data, begin + 1, right);  
49.     }  
50.     else//如果要排序的資料很少，少於等於3個，則直接使用氣泡排序
51.     {  
52.         BubbleSort(data+left, right - left + 1);  
53.     }  
54. }  

五、與中軸相等時的操作

當i或j在掃描中遇到與中軸相等的元素時，是停止掃描還是繼續？

我們仍然採用雙向掃描法，而且從實踐中我們知道，i與j的操作應該相同（停止或繼續）否則，一趟快排後，會出現中軸偏向一邊的現象。

下面以一下極端的例子來說明：

採用三數中值分割法
初始資料：         2  2  2  2  2  2  2  2  2
分割後：             2  2  2  2  2  2  2  2  2
                                i→            ←j
1）繼續掃描（先不考慮越界）