PHP排序演算法之快速排序(Quick Sort)及其最佳化

這篇文章主要介紹了PHP排序演算法之快速排序(Quick Sort)及其最佳化演算法,結合執行個體形式分析了php快速排序的原理、實現方法,並分析了各種最佳化技巧與操作注意事項,需要的朋友可以參考下

本文執行個體講述了PHP排序演算法之快速排序(Quick Sort)及其最佳化演算法。分享給大家供大家參考，具體如下：

基本思想：

快速排序（Quicksort）是對冒泡排序的一種改進。他的基本思想是：通過一趟排序將待排記錄分割成獨立的兩部分，其中一部分的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行快速排序，整個排序過程可以遞迴進行，以達到整個序列有序的目的。

基本演算法步驟：

舉個栗子：

假如現在待排序記錄是：

6 2 7 3 8 9

第一步、建立變數 $low 指向記錄中的第一個記錄，$high 指向最後一個記錄，$pivot 作為樞軸賦值為待排序記錄的第一個元素（不一定是第一個），這裡：

$low = 0;$high = 5;$pivot = 6;

第二步、我們要把所有比 $pivot 小的數移動到 $pivot 的左面，所以我們可以開始尋找比6小的數，從 $high 開始，從右往左找，不斷遞減變數 $high 的值，我們找到第一個下標 3 的資料比 6 小，於是把資料 3 移到下標 0 的位置（$low 指向的位置），把下標 0 的資料 6 移到下標 3，完成第一次比較：

3 2 7 6 8 9

//這時候,$high 減小為 3$low = 0;$high = 3;$pivot = 6;

第三步、我們開始第二次比較，這次要變成找比 $pivot 大的了，而且要從前往後找了。遞加變數 $low，發現下標 2 的資料是第一個比 $pivot 大的，於是用下標 2 （$low 指向的位置）的資料 7 和 指向的下標 3 （$high 指向的位置）的資料的 6 做交換，資料狀態變成下表：

3 2 6 7 8 9

//這時候,$high 減小為 3$low = 2;$high = 3;$pivot = 6;

完成第二步和第三步我們稱為完成一個迴圈。

第四步（也就是開啟下一個迴圈）、模仿第二步的過程執行。

第五步、模仿第三步的過程執行。

執行完第二個迴圈之後，資料狀態如下：

3 2 6 7 8 9

//這時候,$high 減小為 3$low = 2;$high = 2;$pivot = 6;

到了這一步，我們發現 $low 和 $high“碰頭”了：他們都指向了下標 2。於是，第一遍比較結束。得到結果如下，凡是 $pivot(=6) 左邊的數都比它小，凡是 $pivot 右邊的數都比它大。

然後，對 、$pivot 兩邊的資料 {3，2} 和 {7，8，9}，再分組分別進行上述的過程，直到不能再分組為止。

注意：第一遍快速排序不會直接得到最終結果，只會把比k大和比k小的數分到k的兩邊。為了得到最後結果，需要再次對下標2兩邊的數組分別執行此步驟，然後再分解數組，直到數組不能再分解為止（只有一個資料），才能得到正確結果。

演算法實現：

//交換函數function swap(array &$arr,$a,$b){  $temp = $arr[$a];  $arr[$a] = $arr[$b];  $arr[$b] = $temp;}//主函數：function QuickSort(array &$arr){  $low = 0;  $high = count($arr) - 1;  QSort($arr,$low,$high);}

主函數中，由於第一遍快速排序是對整個數組排序的，因此開始是 $low=0,$high=count($arr)-1。

然後 QSort() 函數是個遞迴調用過程，因此對它封裝了一下：

function QSort(array &$arr,$low,$high){  //當 $low >= $high 時表示不能再進行分組，已經能夠得出正確結果了  if($low < $high){    $pivot = Partition($arr,$low,$high); //將$arr[$low...$high]一分為二，算出樞軸值    QSort($arr,$low,$pivot - 1); //對低子表（$pivot左邊的記錄）進行遞迴排序    QSort($arr,$pivot + 1,$high); //對高子表（$pivot右邊的記錄）進行遞迴排序  }}

從上面的 QSort()函數中我們看出，Partition()函數才是整段代碼的核心，因為該函數的功能是：選取當中的一個關鍵字，比如選擇第一個關鍵字。然後想盡辦法將它放到某個位置，使得它左邊的值都比它小，右邊的值都比它大，我們將這樣的關鍵字成為樞軸（pivot）。

直接上代碼：

//選取數組當中的一個關鍵字，使得它處於數組某個位置時，左邊的值比它小，右邊的值比它大，該關鍵字叫做樞軸//使樞軸記錄到位，並返回其所在位置function Partition(array &$arr,$low,$high){  $pivot = $arr[$low];  //選取子數組第一個元素作為樞軸  while($low < $high){ //從數組的兩端交替向中間掃描（當 $low 和 $high 碰頭時結束迴圈）    while($low < $high && $arr[$high] >= $pivot){      $high --;    }    swap($arr,$low,$high); //終於遇到一個比$pivot小的數，將其放到數組低端    while($low < $high && $arr[$low] <= $pivot){      $low ++;    }    swap($arr,$low,$high); //終於遇到一個比$pivot大的數，將其放到數組高端  }  return $low;  //返回high也行，畢竟最後low和high都是停留在pivot下標處}

組合起來的整個代碼如下：

function swap(array &$arr,$a,$b){  $temp = $arr[$a];  $arr[$a] = $arr[$b];  $arr[$b] = $temp;}function Partition(array &$arr,$low,$high){  $pivot = $arr[$low];  //選取子數組第一個元素作為樞軸  while($low < $high){ //從數組的兩端交替向中間掃描    while($low < $high && $arr[$high] >= $pivot){      $high --;    }    swap($arr,$low,$high); //終於遇到一個比$pivot小的數，將其放到數組低端    while($low < $high && $arr[$low] <= $pivot){      $low ++;    }    swap($arr,$low,$high); //終於遇到一個比$pivot大的數，將其放到數組高端  }  return $low;  //返回high也行，畢竟最後low和high都是停留在pivot下標處}function QSort(array &$arr,$low,$high){  if($low < $high){    $pivot = Partition($arr,$low,$high); //將$arr[$low...$high]一分為二，算出樞軸值    QSort($arr,$low,$pivot - 1);  //對低子表進行遞迴排序    QSort($arr,$pivot + 1,$high); //對高子表進行遞迴排序  }}function QuickSort(array &$arr){  $low = 0;  $high = count($arr) - 1;  QSort($arr,$low,$high);}

我們調用演算法：

$arr = array(9,1,5,8,3,7,4,6,2);QuickSort($arr);var_dump($arr);

運行結果：

array(9) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9)}

複雜度分析：

在最優的情況下，也就是選擇數軸處於整個數組的中間值的話，則每一次就會不斷將數組平分為兩半。因此最優情況下的時間複雜度是 O(nlogn) （跟堆排序、歸併排序一樣）。

最壞的情況下，待排序的序列是正序或逆序的，那麼在選擇樞軸的時候只能選到邊緣資料，每次劃分得到的比上一次劃分少一個記錄，另一個劃分為空白，這樣的情況的最終時間複雜度為 O(n^2).

綜合最優與最差情況，平均的時間複雜度是 O(nlogn).

快速排序是一種不穩定排序方法。

由於快速排序是個比較進階的排序，而且被列為20世紀十大演算法之一。。。。如此牛掰的演算法，我們還有什麼理由不去學他呢！

儘管這個演算法已經很牛掰了，但是上面的演算法程式依然有改進的地方，下面具體討論一下

快速排序演算法最佳化

最佳化一：最佳化選取樞軸：

在前面的複雜度分析的過程中，我們看到最壞的情況無非就是當我們選中的樞軸是整個序列的邊緣值。比如這麼一個序列：

9 1 5 8 3 7 4 6 2

按照習慣我們選擇數組的第一個元素作為樞軸，則 $pivot = 9，在一次迴圈下來後劃分為{1，5，8，3，7，4，6，2} 和{ }（空序列），也就是每一次劃分只得到少一個記錄的子序列，而另一個子序列為空白。最終時間複雜度為 O(n^2)。最優的情況是當我們選中的樞軸是整個序列的中間值。但是我們不能每次都去遍曆數組拿到最優值吧？那麼就有了一下解決方案：

1、隨機選取：隨機選取 $low 到 $high 之間的數值，但是這樣的做法有些撞大運的感覺了，萬一沒撞成功呢，那上面的問題還是沒有解決。

2、三數取中法：取三個關鍵字先進行排序，取出中間數作為樞軸。這三個數一般取最左端、最右端和中間三個數，也可以隨機取三個數。這樣的取法得到的樞軸為中間數的可能性就大大提高了。由於整個序列是無序的，隨機播放三個數和從左中右端取出三個數其實就是同一回事。而且隨機數產生器本身還會帶來時間的開銷，因此隨機產生不予考慮。

出於這個想法，我們修改 Partition() 函數：

function Partition(array &$arr,$low,$high){  $mid = floor($low + ($high - $low) / 2);  //計算數組中間的元素的下標  if($arr[$low] > $arr[$high]){    swap($arr,$low,$high);  }  if($arr[$mid] > $arr[$high]){    swap($arr,$mid,$high);  }  if($arr[$low] < $arr[$mid]){    swap($arr,$low,$mid);  }  //經過上面三步之後，$arr[$low]已經成為整個序列左中右端三個關鍵字的中間值  $pivot = $arr[$low];  while($low < $high){  //從數組的兩端交替向中間掃描（當 $low 和 $high 碰頭時結束迴圈）    while($low < $high && $arr[$high] >= $pivot){      $high --;    }    swap($arr,$low,$high); //終於遇到一個比$pivot小的數，將其放到數組低端    while($low < $high && $arr[$low] <= $pivot){      $low ++;    }    swap($arr,$low,$high); //終於遇到一個比$pivot大的數，將其放到數組高端  }  return $low;  //返回high也行，畢竟最後low和high都是停留在pivot下標處}

三數取中法對於小數組有很大可能能溝得出比較理想的 $pivot，但是對於大數組就未必了，因此還有個辦法是九數取中法。。。。。。

最佳化二：最佳化不必要的交換：

現在假如有個待排序的序列如下：

5 1 9 3 7 4 8 6 2

根據三數取中法我們取 5 7 2 中的 5 作為樞軸。

當你按照快速排序演算法走一個迴圈，你會發現 5 的下標變換順序是這樣的：0 -> 8 -> 2 -> 5 -> 4，但是它的最終目標就是 4 的位置，當中的交換其實是不需要的。

根據這個思想，我們改進我們的 Partition() 函數:

function Partition(array &$arr,$low,$high){  $mid = floor($low + ($high - $low) / 2);  //計算數組中間的元素的下標  if($arr[$low] > $arr[$high]){    swap($arr,$low,$high);  }  if($arr[$mid] > $arr[$high]){    swap($arr,$mid,$high);  }  if($arr[$low] < $arr[$mid]){    swap($arr,$low,$mid);  }  //經過上面三步之後，$arr[$low]已經成為整個序列左中右端三個關鍵字的中間值  $pivot = $arr[$low];  $temp = $pivot;  while($low < $high){  //從數組的兩端交替向中間掃描（當 $low 和 $high 碰頭時結束迴圈）    while($low < $high && $arr[$high] >= $pivot){      $high --;    }    //swap($arr,$low,$high); //終於遇到一個比$pivot小的數，將其放到數組低端    $arr[$low] = $arr[$high];  //使用替換而不是交換的方式進行操作    while($low < $high && $arr[$low] <= $pivot){      $low ++;    }    //swap($arr,$low,$high); //終於遇到一個比$pivot大的數，將其放到數組高端    $arr[$high] = $arr[$low];  }  $arr[$low] = $temp;  //將樞軸數值替換回 $arr[$low];  return $low;  //返回high也行，畢竟最後low和high都是停留在pivot下標處}

在上面的改進中，我們使用替換而不是交進行操作，由於在這當中少了多次的資料交換，因此在效能上也是有所提高的。

最佳化三：最佳化小數組的排序方案：

對於一個數學科學家、博士生導師，他可以攻克世界性的難題，可以培育最優秀的數學博士，當讓他去教小學生“1 + 1 = 2”的算術課程，那還真未必比常年在小學裡耕耘的數學老師教的好。換句話說，大材小用有時會變得反而不好用。

也就是說，快速排序對於比較大數組來說是一個很好的排序方案，但是假如數組非常小，那麼快速排序演算法反而不如直接插入排序來得更好（直接插入排序是簡單排序中效能最好的）。其原因在於快速排序用到了遞迴操作，在大量資料排序的時候，這點效能影響相對於它的整體演算法優勢而言是可以忽略的，但如果數組只有幾個記錄需要排序時，這就成了大炮打蚊子的大問題。

因此我們需要修改一下我們的 QSort() 函數：

//規定數組長度閥值#define MAX_LENGTH_INSERT_SORT 7function QSort(array &$arr,$low,$high){  //當 $low >= $high 時表示不能再進行分組，已經能夠得出正確結果了  if(($high - $low) > MAX_LENGTH_INSERT_SORT){    $pivot = Partition($arr,$low,$high); //將$arr[$low...$high]一分為二，算出樞軸值    QSort($arr,$low,$pivot - 1); //對低子表（$pivot左邊的記錄）進行遞迴排序    QSort($arr,$pivot + 1,$high); //對高子表（$pivot右邊的記錄）進行遞迴排序  }else{    //直接插入排序    InsertSort($arr);  }}

PS：上面的直接插入排序演算法大家可以參考：《PHP排序演算法之直接插入排序（Straight Insertion Sort）》

在這裡我們增加一個判斷，當 $high - $low 不大於一個常數時（有資料認為 7 比較合適，也有認為 50 比較合適，實際情況可以是適當調整），就用直接插入排序，這樣就能保證最大化的利用這兩種排序的優勢來完成排序工作。

最佳化四：最佳化遞迴操作：

大家知道，遞迴對效能時有一定影響的，QSort()函數在其尾部有兩次遞迴的操作，如果待排序的序列劃分極端不平衡（就是我們在選擇樞軸的時候不是中間值），那麼遞迴的深度將趨近於 n，而不是平衡時的 log₂n，這就不僅僅是速度快慢的問題了。

我們也知道，遞迴是通過棧來實現的，棧的大小是很有限的，每次遞迴調用都會耗費一定的棧空間，函數的參數越多，每次遞迴耗費的空間也越多，因此如果能減少隊規，將會大大提高效能。

聽說，遞迴都可以改造成迴圈實現。我們在這裡就是使用迴圈去最佳化遞迴。（關於遞迴與迴圈大家可以參考知乎裡面的討論 《所有遞迴都可以改寫成迴圈嗎？》）

我們對QSort() 函數尾部遞迴進行最佳化：

//規定數組長度閥值#define MAX_LENGTH_INSERT_SORT 7function QSort(array &$arr,$low,$high){  //當 $low >= $high 時表示不能再進行分組，已經能夠得出正確結果了  if(($high - $low) > MAX_LENGTH_INSERT_SORT){    while($low < $high){      $pivot = Partition($arr,$low,$high); //將$arr[$low...$high]一分為二，算出樞軸值      QSort($arr,$low,$pivot - 1); //對低子表（$pivot左邊的記錄）進行遞迴排序      $low = $pivot + 1;    }  }else{    //直接插入排序    InsertSort($arr);  }}

在上面，我們使用迴圈替換遞迴，減少了之前一般的遞迴量。結果是一樣的，但是採用迴圈而不是遞迴的方法可以縮減堆棧的深度，從而提高了整體效能。