【算法】快速排序算法的編碼和優化
參考資料算法
《算法（第4版）》 — — Robert Sedgewick， Kevin Wayne
《啊哈！ 算法》 — — 啊哈磊
《數據結構（教材）》 — — 嚴蔚敏，吳偉民
快速排序算法的編碼描述
快排的基本思路
快速排序的基本思路是：
- 先經過第一趟排序，將數組原地劃分爲兩部分，其中一部分的全部數據都小於另外一部分的全部數據。原數組被劃分爲2份
- 經過遞歸的處理， 再對原數組分割的兩部分分別劃分爲兩部分，一樣是使得其中一部分的全部數據都小於另外一部分的全部數據。 這個時候原數組被劃分爲了4份
- 就1,2被劃分後的最小單元子數組來看，它們仍然是無序的，可是！ 它們所組成的原數組卻逐漸向有序的方向前進。
- 到最後， 數組被劃分爲多個由一個元素或多個相同元素組成的單元， 這時候整個數組就有序了
總結： 經過第一趟排序，將原數組A分爲B和C兩部分， 總體上B<C, 第二躺排序時候將B劃分爲B1，B2兩部分， 使得B1<B2, 同理C1<C2。那麼經過兩趟排序， 從B1/B2/C1/C2的長度的單元看待整個數組， 從左至右 B1<B2<C1<C2, 數組是「有序」的， 而且隨着排序的深刻，原數組有序性愈來愈強
總體的排序過程以下圖所示（暫且無論實現的具體細節）
如上圖所示， 數組
3 1 4 1 5 9 2 6 5 3
經過第一趟排序被分紅了2 1 1 和4 5 9 3 6 5 3兩個子數組，且對任意元素，左子數組總小於右子數組
經過不斷遞歸處理，最終獲得
1 1 2 3 3 4 5 5 6
這個有序的數組
快排的實現步驟
快排具體的實現步驟以下圖所示：
圖中的步驟3，4不難理解，這裏就很少贅述，由於步驟3中的遞歸思想是你們比較熟悉的， 步驟4中的「組合」其實就只是個概念上的詞，由於全部的子數組原本就鏈接在一塊兒，只要全部的遞歸結束了，整個數組就是有序的。
下面我就只講解1和2步驟， 而在1,2中，關鍵在於如何實現「劃分」數組
切分的關鍵點： 基準元素， 左遊標和右遊標
劃分的過程有三個關鍵點：「基準元素」， 「左遊標」 和「右遊標」。數據結構
- 基準元素：它是將數組劃分爲兩個子數組的過程當中， 用於界定大小的值， 以它爲判斷標準， 將小於它的數組元素「劃分」到一個「小數值數組」裏， 而將大於它的數組元素「劃分」到一個「大數值數組」裏面。這樣，咱們就將數組分割爲兩個子數組， 而其中一個子數組裏的元素恆小於另外一個子數組裏的元素
- 左遊標： 它一開始指向待分割數組最左側的數組元素。在排序過程當中，它將向右移動
- 右遊標： 它一開始指向待分割數組最右側的數組元素。在排序過程當中，它將向左移動
【注意】
1.上面描述的基準元素/右遊標/左遊標都是針對單趟排序過程的， 也就是說，在總體排序過程的多趟排序中，各趟排序取得的基準元素/右遊標/左遊標通常都是不一樣的
2. 在不一樣的教材裏，基準元素也叫「樞軸」，「關鍵字」， 「劃分」也叫「切分」
那這基準元素-右遊標-左遊標三個關鍵點是如何融會貫通，搞定一趟切分（劃分）的呢？
一趟切分的具體過程
切分的具體過程如圖所示。在下圖中，基準元素是v, 左遊標是i, 右遊標是j
i一開始指向數組頭部元素的位置lo, 切分時向右移動， j一開始指向數組末端元素hi,隨後向左移動， 當左右遊標相遇的時候，一趟切分就完成了。
固然， 看到這裏你可能很懵懂，你可能會問：
- 「基準元素v是怎麼選的？」
- 遊標i,j的移動的過程當中發生了什麼事情（好比元素交換）？，
- 爲何左右遊標相遇時一趟切分就完成了？
讓咱們繼續往下看：
基準元素的選取
首先，在原則上，基準元素的選取是任意的
但咱們通常選取數組的第一個元素爲基準元素（假設數組是隨機分佈的）
下面以啊哈磊老師的圖示爲例：
假設下面的是咱們的待排序的數組的話， 根據咱們的頭元素做爲基準元素的原則，士兵i下面的數組元素 「6」 就是咱們選定的第一趟排序的基準元素
（做爲入門，啊哈磊老師的《啊哈，算法》裏的圖示仍是頗有趣的！ 這裏向你們安利一下）
【注意】下面在優化中會講關於基準元素的選取的訣竅， 但在快排的基礎編碼裏，咱們只要記住把頭部元素看成基準元素就夠了（假設數組元素是隨機分佈的）
左右遊標掃描和元素交換
在選取了基準元素以後， 切分就正式開始了。這時候，左右遊標開始分別向右/左移動，它們遵循的規則分別是：
- 左遊標向右掃描， 跨過全部小於基準元素的數組元素, 直到遇到一個大於或等於基準元素的數組元素， 在那個位置停下。
- 右遊標向左掃描， 跨過全部大於基準元素的數組元素, 直到遇到一個大於或等於基準元素的數組元素，在那個位置停下
當左右遊標掃描分兩種狀況（或者說是兩個前後階段...）
- 左右遊標沒有相遇
- 左右遊標相遇了
在下圖中， 左遊標就是士兵i, 而右遊標是士兵j啦。
1.首先，右遊標j會向左跨過全部大於基準元素的元素， 因此士兵j向左跨過了板磚8和10， 而後當他遇到了「小於等於」基準元素6的元素5時候， 「哎呀， 不能再前進了，在這裏打住吧！」， 因而右遊標就在5處停了下來，
2.而後， 士兵i（左遊標）跨過了小於基準元素6的1和2，而後遇到了「大於等於」6的7，在7處停了下來。
3. 停下來以後， 左右遊標所指的數組元素交換了它們的值（兩個士兵交換了他們腳下的板磚）
下圖同上：
遊標掃描和元素交換的意義
很明顯， 兩個遊標士兵的「工做」 就是不斷靠近，並檢查有沒有小於（大於）規定要求（即基準元素6）的板磚（元素），一旦發現， 就「丟」到對面去， 而當他們相遇的時候， 大小關係嚴格的兩塊子數組也就分割出來了
【注意】
1.要注意一點： 咱們選取的基準元素和左遊標最初指定的元素是相同的！ 那麼就咱們就會發現一個問題: 當左遊標向右掃描的時候，第一個遇到的「大於或等於」的元素就是它自己， 那麼問題來了： 需不須要停下來呢？ 固然根據邏輯思考能夠得出這是沒必要要的，因此下面我會結合算法指出這一細節： 左遊標向右掃描的時候其實忽略了它最初所指的位置——頭元素的比較
2. 必須等一個「士兵」（遊標）先走完， 另外一個「士兵」（遊標）才能走，不能每人輪流走一步...
左右遊標相遇
承接上文， 此次眼看士兵i和士兵j就要相遇了！ 首先士兵j先走，當它遇到3的位置的時候，由於3「小於等於」6，因此士兵j就停下來了。再而後士兵i向右走，但由於他和士兵j「碰頭」了，因此士兵i只能無奈地「提早」在3停住了（若是沒和j碰面士兵i是能走到9的!）
因此這就是左右遊標掃描相遇時候遵循的原則： 只相遇， 不交叉
【注意】這裏你可能會問： 在咱們制定的規則裏， 左遊標先掃描和右遊標先掃描有區別嗎？ （若是你這樣想的話就和我想到一塊去了...嘿嘿），由於就上圖而言,兩種狀況下一趟排序中兩個遊標相遇的位置是不一樣的（通常而言，除非相遇位置的下方的元素恰好和基準元素相同）：dom
- 若是右遊標先掃描，左右遊標相遇的位置應該是3上方（圖示）
- 但若是左遊標先掃描， 左右遊標相遇的位置倒是9上方
經過編碼驗證和翻閱書籍，我得出的結論是： 這對排序的劃分過程有影響，但對最終結果是沒有具體的影響的。特別的，在《數據結構》這本書中採起的是右遊標先掃描，而在《算法（第四版）》書中，則採起左遊標先掃描的策略
基準元素歸位
當到達了我上面所說的「左右遊標相遇」這個階段後， 咱們發現， 左右兩個子數組已經基本有序了，即分紅了 1 2 5 4 3和9 7 10 8 這兩段元素，其中前一段元素都小於後一段元素
等等！ 好像有兩個數字違和感很強地打破了這個大小關係， 那就是6！ （基準元素）
以下所示：
6 1 2 5 4 3 9 7 10 8
這時候咱們發現整個數組的組成是這樣的： 大小居中的基準元素 + 小數值數組 + 大數值數組
因此咱們只要把基準元素6和遊標相遇元素3換一下， 不就能夠變成： 小數值數組 + 大小居中的基準元素 + 大數值數組 了嗎？
即
1 2 5 4 3 6 9 7 10 8
如圖所示
至此， 一趟排序結束， 回到中間的6已經處於有序狀態，只要再對左右兩邊的元素進行遞歸處理就能夠了
總結一趟排序的過程
OK，這裏讓咱們總結下一趟快速排序的四個過程：
一趟排序全過程圖示
（A - Z 字母排序， A最小， Z最大）
快速排序代碼展現
具體的代碼
這是咱們的輔助函數exchange: 用於交換任意兩個數組元素的位置：
// 交換兩個數組元素 private static void exchange(int [] a , int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; }
這是切分函數partition， 它完成了一輪排序的主要工做，使得待分割數組以基準元素爲界，分紅了一個小數值數組和一個大數值數組
private static int partition (int[] a, int low, int high) { int i = low, j = high+1; // i, j爲左右掃描指針 PS： 思考下爲何j比i 多加一個1呢？ int pivotkey = a[low]; // pivotkey 爲選取的基準元素（頭元素） while(true) { while (a[--j]>pivotkey) { if(j == low) break; } // 右遊標左移 while(a[++i]<pivotkey) { if(i == high) break; } // 左遊標右移 if(i>=j) break; // 左右遊標相遇時候中止， 因此跳出外部while循環 else exchange(a,i, j) ; // 左右遊標未相遇時中止, 交換各自所指元素，循環繼續 } exchange(a, low, j); // 基準元素和遊標相遇時所指元素交換，爲最後一次交換 return j; // 一趟排序完成， 返回基準元素位置 }
這是主體函數sort, 將partition遞歸處理
private static void sort (int [] a, int low, int high) { if(high<= low) { return; } // 終止遞歸 int j = partition(a, low, high); // 調用partition進行切分 sort(a, low, j-1); // 對上一輪排序(切分)時，基準元素左邊的子數組進行遞歸 sort(a, j+1, high); // 對上一輪排序(切分)時，基準元素右邊的子數組進行遞歸 }
對切分函數partition的解讀
1. 直觀上看， partition由兩部分組成： 外部while循環和兩個並列的內部while循環。
2. 內部While循環的做用是使得左右遊標相互靠近
例如對：
while (a[--j]>pivotkey) { ... }
先將右遊標左移一位，而後判斷指向的數組元素和基準元素pivotkey比較大小， 若是該元素大於基準元素， 那麼循環繼續，j再次減1，右遊標再次左移一位...... （循環體能夠看做是空的）函數
3.外部While循環的做用是不斷經過exchange使得「逆序」元素的互相交換， 不斷向左子數組小於右子數組的趨勢靠近，
對
if(i>=j) break;
從i < j到 i == j 表明了「遊標未相遇」到「遊標相遇」的過分過程，此時跳出外部循環， 切分已接近完成，緊接着經過 exchange(a, low, j) 交換基準元素和相遇遊標所指元素的位置， low是基準元素的位置（頭部元素）, j是當前兩個遊標相遇的位置性能
4. 第一個內部while循環體裏面的的 if(j == low) break；判斷實際上是多餘的，能夠去除。
由於在
while (a[--j]>pivotkey) { if(j == low) break; } // 右遊標左移
中，當隨着右遊標左移，到j = low + 1的時候，有 a[--j] == pivotkey爲true（二者都是基準元素），自動跳出了while循環，因此就不須要在循環體裏再判斷 j == low 了測試
5. 注意一個細節： j 比 i 多加了一個1，爲何？ 以下
int i = low, j = high+1
結合下面兩個While循環中的判斷條件：優化
while (a[--j]>pivotkey) { ... } while (a[++i]<pivotkey) { ... }
可知道， 左遊標 i 第一次自增的時候， 跳過了對基準元素 a[low] 所執行的 a[low] < pivotkey判斷, 這是由於在咱們當前的算法方案裏，基準元素和左遊標初始所指的元素是同一個，因此沒有執行a[low]>pivotke這個判斷的必要。因此跳過（ 一開始a[low] == pivotkey，若是執行判斷那麼一開始就會跳出內While循環，這顯然不是咱們但願看到的）ui
而相比之下，右遊標卻必需要對它初始位置所指的元素執行a[++i]<pivotkey ， 因此 j 比 i 多加了一個
對主體函數sort的解讀
1. high<= low是判斷遞歸結束的條件
2. int j = partition(a, low, high); 有兩種做用： 一是進行一輪切分， 二是取得上一輪的基準元素的最終位置j, 傳遞給另外兩個sort函數，經過另外兩個sort函數的調用
sort(a, low, j-1); sort(a, j+1, high);
進行下一輪遞歸，設置j -1 和j + 1 是由於上一輪基準元素的位置已是有序的了，不要再歸入下一輪遞歸裏編碼
快速排序QuickSort類的所有代碼：
public class QuickSort { // 交換兩個數組元素 private static void exchange(int [] a , int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } private static int partition (int[] a, int low, int high) { int i = low, j = high+1; // i, j爲左右掃描指針 PS： 思考下爲何j比i 多加一個1呢？ int pivotkey = a[low]; // pivotkey 爲選取的基準元素（頭元素） while(true) { while (a[--j]>pivotkey) { if(j == low) break; } // 右遊標左移 while(a[++i]<pivotkey) { if(i == high) break; } // 左遊標右移 if(i>=j) break; // 左右遊標相遇時候中止， 因此跳出外部while循環 else exchange(a,i, j) ; // 左右遊標未相遇時中止, 交換各自所指元素，循環繼續 } exchange(a, low, j); // 基準元素和遊標相遇時所指元素交換，爲最後一次交換 return j; // 一趟排序完成， 返回基準元素位置 } private static void sort (int [] a, int low, int high) { if(high<= low) { return; } // 當high == low, 此時已經是單元素子數組，天然有序， 故終止遞歸 int j = partition(a, low, high); // 調用partition進行切分 sort(a, low, j-1); // 對上一輪排序(切分)時，基準元素左邊的子數組進行遞歸 sort(a, j+1, high); // 對上一輪排序(切分)時，基準元素右邊的子數組進行遞歸 } public static void sort (int [] a){ //sort函數重載， 只向外暴露一個數組參數 sort(a, 0, a.length - 1); } }
測試代碼
public class Test { public static void main (String [] args) { int [] array = {4,1,5,9,2,6,5,6,1,8,0,7 }; QuickSort.sort(array); for (int i = 0; i < array.length; i++) { System.out.print(array[i]); } } }
結果：
01124556789
優化點一 —— 切換到插入排序
對於小數組而言， 快速排序比插入排序要慢， 因此在排序小數組時應該切換到插入排序。
只要把sort函數中的
if(high<= low) { return; }
改爲：
if(high<= low + M) { Insertion.sort(a,low, high) return; } // Insertion表示一個插入排序類
就能夠了，這樣的話，這條語句就具備了兩個功能：
1. 在適當時候終止遞歸
2. 當數組長度小於M的時候（high-low <= M）， 不進行快排，而進行插排
轉換參數M的最佳值和系統是相關的，通常來講， 5到15間的任意值在多數狀況下都能使人滿意
例如， 將sort函數改爲：
private static void sort (int [] a, int low, int high) { if(high<= low + 10) { Insertion.sort(a,low, high) return; } // Insertion表示一個插入排序類 int j = partition(a, low, high); // 調用partition進行切分 sort(a, low, j-1); // 對上一輪排序(切分)時，基準元素左邊的子數組進行遞歸 sort(a, j+1, high); // 對上一輪排序(切分)時，基準元素右邊的子數組進行遞歸 }
優化點二 —— 基準元素選取的隨機化
上面說過，基準元素的選取是任意的，可是不一樣的選取方式對排序性能的影響很大。
在上面全部的快速排序的例子中，咱們都是固定選取基準元素，這種操做作了一個假設性的前提：數組元素的分佈是隨機的。而若是數組不是隨機的，而是有必定順序的，甚至在最壞的狀況下:徹底正序或徹底逆序， 這個時候麻煩就來了： 快排所消耗的時間大大延長，徹底達不到快排應有的效果。
因此爲了保證快排算法的隨機化，咱們必須進行一些優化。
下面介紹的方法有三種：
- 排序前打亂數組的順序
- 經過隨機數保證取得的基準元素的隨機性
- 三數取中法取得基準元素（推薦）
1. 排序前打亂數組的順序
public static void sort (int [] a){ StdRandom.shuffle(a) // 外部導入的亂序算法，打亂數組的分佈 sort(a, 0, a.length - 1); }
固然來了，由於亂序函數的運行，這會增長一部分耗時，但這多是值得的
2.經過隨機數保證取得的基準元素的隨機性
private static int getRandom (int []a, int low, int high) { int RdIndex = (int) (low + Math.random()* (high - low)); // 隨機取出其中一個數組元素的下標 exchange(a, RdIndex, low); // 將其和最左邊的元素互換 return a[low]; } private static int partition (int[] a, int low, int high) { int i = low, j = high+1; // i, j爲左右掃描指針 PS： 思考下爲何j比i 多加一個1呢？ int pivotkey = getRandom (a, low, high); // 基準元素隨機化 while(true) { while (a[--j]>pivotkey) { if(j == low) break; } // 右遊標左移 while(a[++i]<pivotkey) { if(i == high) break; } // 左遊標右移 if(i>=j) break; // 左右遊標相遇時候中止， 因此跳出外部while循環 else exchange(a,i, j) ; // 左右遊標未相遇時中止, 交換各自所指元素，循環繼續 } exchange(a, low, j); // 基準元素和遊標相遇時所指元素交換，爲最後一次交換 return j; // 一趟排序完成， 返回基準元素位置 }
3. 三數取中法（推薦）
通常認爲， 當取得的基準元素是數組元素的中位數的時候，排序效果是最好的，可是要篩選出待排序數組的中位數的成本過高， 因此只能從待排序數組中選取一部分元素出來再取中位數， 經大量實驗顯示： 當篩選數組的長度爲3時候，排序效果是比較好的， 因此由此發展出了三數取中法：
三數取中法： 分別取出數組的最左端元素，最右端元素和中間元素， 在這三個數中取出中位數，做爲基準元素。
package mypackage; public class QuickSort { // 交換兩個數組元素 private static void exchange(int [] a , int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } // 選取左中右三個元素，求出中位數， 放入數組最左邊的a[low]中 private static int selectMiddleOfThree(int[] a, int low, int high) { int middle = low + (high - low)/2; // 取得位於數組中間的元素middle
if(a[low]>a[high]) { exchange(a, low, high); //此時有 a[low] < a[high] } if(a[middle]>a[high]){ exchange(a, middle, high); //此時有 a[low], a[middle] < a[high] } if(a[middle]>a[low]) { exchange(a, middle, low); //此時有a[middle]< a[low] < a[high] } return a[low]; // a[low]的值已經被換成三數中的中位數， 將其返回 } private static int partition (int[] a, int low, int high) { int i = low, j = high+1; // i, j爲左右掃描指針 PS： 思考下爲何j比i 多加一個1呢？ int pivotkey = selectMiddleOfThree( a, low, high); while(true) { while (a[--j]>pivotkey) { if(j == low) break; } // 右遊標左移 while(a[++i]<pivotkey) { if(i == high) break; } // 左遊標右移 if(i>=j) break; // 左右遊標相遇時候中止， 因此跳出外部while循環 else exchange(a,i, j) ; // 左右遊標未相遇時中止, 交換各自所指元素，循環繼續 } exchange(a, low, j); // 基準元素和遊標相遇時所指元素交換，爲最後一次交換 return j; // 一趟排序完成， 返回基準元素位置 } private static void sort (int [] a, int low, int high) { if(high<= low) { return; } // 當high == low, 此時已經是單元素子數組，天然有序， 故終止遞歸 int j = partition(a, low, high); // 調用partition進行切分 sort(a, low, j-1); // 對上一輪排序(切分)時，基準元素左邊的子數組進行遞歸 sort(a, j+1, high); // 對上一輪排序(切分)時，基準元素右邊的子數組進行遞歸 } public static void sort (int [] a){ //sort函數重載， 只向外暴露一個數組參數 sort(a, 0, a.length - 1); } }
優化點三 —— 去除沒必要要的邊界檢查
我在上面說過：「 第一個內部while循環體裏面的的 if(j == low) break；判斷實際上是多餘的，能夠去除」
（請把文章往上翻到標題—「對切分函數partition的解讀」中的第4點）
那麼， 能不能把另一個邊界檢查 if(i == high) break; 也去除呢？ 固然是不能直接去除的，可是咱們能夠經過一些技巧使得咱們可以去除它
首先要理解的是 if(i == high) break;的做用： 防止 i 增長到超過數組的上界， 形成數組越界的錯誤。
那麼按照一樣的思考方式，對於
while(a[++i]<pivotkey) { if(i == high) break; }
咱們只要嘗試把這一做用交給a[++i]<pivotkey去完成， 不就能夠把 if(i == high) break; 給去掉了嗎？
這裏的技巧就是： 在排序前先把整個數組中最大的元素移到數組的最右邊，這樣的話， 就算左遊標i增長（右移）到數組的最右端，a[++i]<pivotkey也會斷定爲false(數組最大值固然是大於或等於基準元素的)， 從而沒法越界。
代碼：
public class QuickSort { // 交換兩個數組元素 private static void exchange(int [] a , int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } //將原數組裏最大的元素移到最右邊， 構造「哨兵」 private static void Max(int [] a) { int max = 0; for(int i = 1; i<a.length;i++) { if(a[i]>a[max]) { max = i; } } exchange(a, max, a.length -1); } private static int partition (int[] a, int low, int high) { int i = low, j = high+1; // i, j爲左右掃描指針 PS： 思考下爲何j比i 多加一個1呢？ int pivotkey = a[low]; // pivotkey 爲選取的基準元素（頭元素） while(true) { while (a[--j]>pivotkey) { } // 空的循環體 while(a[++i]<pivotkey) { } // 空的循環體 if(i>=j) break; // 左右遊標相遇時候中止， 因此跳出外部while循環 else exchange(a,i, j) ; // 左右遊標未相遇時中止, 交換各自所指元素，循環繼續 } exchange(a, low, j); // 基準元素和遊標相遇時所指元素交換，爲最後一次交換 return j; // 一趟排序完成， 返回基準元素位置 } private static void sort (int [] a, int low, int high) { if(high<= low) { return; } // 當high == low, 此時已經是單元素子數組，天然有序， 故終止遞歸 int j = partition(a, low, high); // 調用partition進行切分 sort(a, low, j-1); // 對上一輪排序(切分)時，基準元素左邊的子數組進行遞歸 sort(a, j+1, high); // 對上一輪排序(切分)時，基準元素右邊的子數組進行遞歸 } public static void sort (int [] a){ //sort函數重載， 只向外暴露一個數組參數 Max(a); // 將原數組裏最大元素移到最右邊， 構造「哨兵」 sort(a, 0, a.length - 1); } }
若是看到這裏對「哨兵」這個概念還不是很清楚的話，看看下面這張圖示：
《三種哨兵》
關於哨兵三再說幾句： 在處理內部子數組的時候，右子數組中最左側的元素能夠做爲左子數組右邊界的哨兵（可能有點繞）
優化點四 —— 三切分快排（針對大量重複元素）
普通的快速排序還有一個缺點， 那就是會交換一些相同的元素
回憶一下我在前面提到的快排中對左右遊標指定的規則：
- 左遊標向右掃描， 跨過全部小於基準元素的數組元素, 直到遇到一個大於或等於基準元素的數組元素， 在那個位置停下。
- 右遊標向左掃描， 跨過全部大於基準元素的數組元素，直到遇到一個大於或等於基準元素的數組元素，在那個位置挺停下
特別的， 當左右遊標都指向和基準元素相同的元素時候， 沒必要要的交換就發生了
如圖：
（下圖中基準元素是6）
因此由此人們研究出了三切分快排（三路劃分） ， 在左右遊標的基礎上，再增長了一個遊標，用於處理和基準元素相同的元素
代碼以下：
package mypackage; public class Quick3way { public static void exchange(int [] a , int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } public static void sort (int [] a, int low, int high) { if(low>=high) { return; } int lt = low, gt = high, i =low+1; int v = a[low]; while(i<=gt) { int aValue = a[i]; if(aValue>v) { exchange(a, i, gt--); } else if(aValue<v) { exchange(a, i++, lt++); } else{ i++; } } sort(a, low, lt-1); sort(a, gt+1, high); } public static void sort (int [] a) { sort(a, 0, a.length - 1); } }
切分軌跡：
（A - Z 字母排序， A最小， Z最大）
（很差意思，pdf書裏的截圖實在太模糊了，因此我本身
用手機照了一張）
相關文章
- 1. 快速排序的優化算法
- 2. 快速排序算法及其優化
- 3. 【算法】歸併排序算法的編碼和優化
- 4. 快速排序算法與舍伍德快速排序算法
- 5. C++編程解析-算法-排序-快速排序算法
- 6. 【排序算法】快速排序算法代碼演示
- 7. 排序算法(三)：快速排序和三向快速排序
- 8. 算法排序----快速排序法
- 9. 雙路快速排序算法及三路快速排序算法可視化
- 10. 快速排序算法和外部排序算法
- 更多相關文章...
- • ADO 排序 - ADO 教程
- • XML 編碼 - XML 教程
- • 算法總結-歸併排序
- • 算法總結-廣度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 快速排序的優化算法
- 2. 快速排序算法及其優化
- 3. 【算法】歸併排序算法的編碼和優化
- 4. 快速排序算法與舍伍德快速排序算法
- 5. C++編程解析-算法-排序-快速排序算法
- 6. 【排序算法】快速排序算法代碼演示
- 7. 排序算法(三)：快速排序和三向快速排序
- 8. 算法排序----快速排序法
- 9. 雙路快速排序算法及三路快速排序算法可視化
- 10. 快速排序算法和外部排序算法