PHP面試：儘量多的說出你知道的排序算法
預警
本文適合對於排序算法不太瞭解的新手同窗觀看，大佬直接忽略便可。由於考慮到連貫性，因此篇幅較長。老鐵們看完須要大概一個小時，可是從入門到徹底理解可能須要10個小時(哈哈哈，以我本身的經從來計算的)，因此各位老鐵能夠先收藏下來，同步更新在Github，本文引用到的全部算法的實如今這個地址，天天抽點時間理解一個排序算法便可。php
排序和他們的類型
咱們的數據大多數狀況下是未排序的，這意味着咱們須要一種方法來進行排序。咱們經過將不一樣元素相互比較並提升一個元素的排名來完成排序。在大多數狀況下，若是沒有比較，咱們就沒法決定須要排序的部分。在比較以後，咱們還須要交換元素，以便咱們能夠對它們進行從新排序。良好的排序算法具備進行最少的比較和交換的特徵。除此以外，還存在基於非比較的排序，這類排序不須要比較數據來進行排序。咱們將在這篇文章中爲各位老鐵介紹這些算法。如下是本篇文章中咱們將要討論的一些排序算法：git
- Bubble sort
- Insertion sort
- Selection sort
- Quick sort
- Merge sort
- Bucket sort
以上的排序能夠根據不一樣的標準進行分組和分類。例如簡單排序，高效排序，分發排序等。咱們如今將探討每一個排序的實現和複雜性分析，以及它們的優缺點。github
時間空間複雜度以及穩定性
咱們先看下本文提到的各種排序算法的時間空間複雜度以及穩定性。各位老鐵能夠點擊這裏瞭解更多。算法
冒泡排序
冒泡排序是編程世界中最常討論的一個排序算法，大多數開發人員學習排序的第一個算法。冒泡排序是一個基於比較的排序算法，被認爲是效率最低的排序算法之一。冒泡排序老是須要最大的比較次數，平均複雜度和最壞複雜度都是同樣的。編程
冒泡排序中，每個待排的項目都會和剩下的項目作比較，而且在須要的時候進行交換。下面是冒泡排序的僞代碼。segmentfault
procedure bubbleSort(A: list of sortable items)
n = length(A)
for i = 0 to n inclusive do
for j = 0 to n - 1 inclusive do
if A[j] > A[j + 1] then
swap(A[j + 1], A[j])
end if
end for
end for
end procedure
正如咱們從前面的僞代碼中看到的那樣，咱們首先運行一個外循環以確保咱們迭代每一個數字，內循環確保一旦咱們指向某個項目，咱們就會將該數字與數據集合中的其餘項目進行比較。下圖顯示了對列表中的一個項目進行排序的單次迭代。假設咱們的數據包含如下項目：20,45,93,67,10,97,52,88,33,92。第一次迭代將會是如下步驟：數組
有背景顏色的項目顯示的是咱們正在比較的兩個項目。咱們能夠看到，外部循環的第一次迭代致使最大的項目存儲在列表的最頂層位置。而後繼續，直到咱們遍歷列表中的每一個項目。如今讓咱們使用PHP實現冒泡排序算法。數據結構
咱們可使用PHP數組來表示未排序的數字列表。因爲數組同時具備索引和值，咱們根據位置輕鬆迭代每一個項目，並將它們交換到合適的位置。app
function bubbleSort(&$arr) : void
{
$swapped = false;
for ($i = 0, $c = count($arr); $i < $c; $i++) {
for ($j = 0; $j < $c - 1; $j ++) {
if ($arr[$j + 1] < $arr[$j]) {
list($arr[$j], $arr[$j + 1]) = array($arr[$j + 1], $arr[$j]);
}
}
}
}
冒泡排序的複雜度分析
對於第一遍，在最壞的狀況下，咱們必須進行n-1比較和交換。 對於第2次遍歷，在最壞的狀況下，咱們須要n-2比較和交換。 因此，若是咱們一步一步地寫它，那麼咱們將看到：複雜度= n-1 + n-2 + ..... + 2 + 1 = n *（n-1）/ 2 = O(n2)。所以，冒泡排序的複雜性是O(n2)。 分配臨時變量，交換，遍歷內部循環等須要一些恆定的時間，可是咱們能夠忽略它們，由於它們是不變的。如下是冒泡排序的時間複雜度表，適用於最佳，平均和最差狀況：數據結構和算法
| best time complexity | Ω(n) |
|---|---|
| worst time complexity | O(n2) |
| average time complexity | Θ(n2) |
| space complexity (worst case) | O(1) |
儘管冒泡排序的時間複雜度是O(n2)，可是咱們可使用一些改進的手段來減小排序過程當中對數據的比較和交換次數。最好的時間複雜度是O(n)是由於咱們至少要一次內部循環才能夠肯定數據已是排好序的狀態。
冒泡排序的改進
冒泡排序最重要的一個方面是，對於外循環中的每次迭代，都會有至少一次交換。若是沒有交換，則列表已經排序。咱們能夠利用它改進咱們的僞代碼
procedure bubbleSort(A: list of sortable items)
n = length(A)
for i = 1 to n inclusive do
swapped = false
for j = i to n - 1 inclusive do
if A[j] > A[j + 1] then
swap(A[j], A[j + 1])
swapped = true
endif
end for
if swapped = false
break
endif
end for
end procedure
正如咱們所看到的，咱們如今爲每一個迭代設置了一個標誌爲false，咱們指望在內部迭代中，標誌將被設置爲true。若是內循環完成後標誌仍然爲假，那麼咱們能夠打破外循環。
function bubbleSort(&$arr) : void
{
for ($i = 0, $c = count($arr); $i < $c; $i++) {
$swapped = false;
for ($j = 0; $j < $c - 1; $j++) {
if ($arr[$j + 1] < $arr[$j]) {
list($arr[$j], $arr[$j + 1]) = array($arr[$j + 1], $arr[$j]);
$swapped = true;
}
}
if (!$swapped) break; //沒有發生交換，算法結束
}
}
咱們還發現，在第一次迭代中，最大項放置在數組的右側。在第二個循環，第二大的項將位於數組右側的第二個。咱們能夠想象出來在每次迭代以後，第i個單元已經存儲了已排序的項目，不須要訪問該索引和
作比較。所以，咱們能夠從內部迭代減小迭代次數並減小比較。這是咱們的第二個改進的僞代碼
procedure bubbleSort(A: list of sortable items)
n = length(A)
for i = 1 to n inclusive do
swapped = false
for j = 1 to n - i - 1 inclusive do
if A[j] > A[j + 1] then
swap(A[j], A[j + 1])
swapped = true
endif
end for
if swapped = false
break
end if
end for
end procedure
下面的是PHP的實現
function bubbleSort(&$arr) : void
{
for ($i = 0, $c = count($arr); $i < $c; $i++) {
$swapped = false;
for ($j = 0; $j < $c - $i - 1; $j++) {
if ($arr[$j + 1] < $arr[$j]) {
list($arr[$j], $arr[$j + 1]) = array($arr[$j + 1], $arr[$j]);
$swapped = true;
}
if (!$swapped) break; //沒有發生交換，算法結束
}
}
}
咱們查看代碼中的內循環，惟一的區別是$j < $c - $i - 1；其餘部分與第一次改進同樣。所以，對於20、4五、9三、6七、十、9七、5二、8八、3三、92, 咱們能夠很認爲，在第一次迭代以後，頂部數字97將不被考慮用於第二次迭代比較。一樣的狀況也適用於93，將不會被考慮用於第三次迭代。
咱們看看前面的圖，腦海中應該立刻想到的問題是「92不是已經排序了嗎？咱們是否須要再次比較全部的數字？是的，這是一個好的問題。咱們完成了內循環中的最後一次交換後能夠知道在哪個位置，以後的數組已經被排序。所以，咱們能夠爲下一個循環設置一個界限，僞代碼是這樣的：
procedure bubbleSort(A: list of sortable items)
n = length(A)
bound = n - 1
for i = 1 to n inclusive do
swapped = false
bound = 0
for j = 1 to bound inclusive do
if A[j] > A[j + 1] then
swap(A[j], A[j + 1])
swapped = true
newbound = j
end if
end for
bound = newbound
if swapped = false
break
endif
end for
end procedure
這裏，咱們在每一個內循環完成以後設定邊界，而且確保咱們沒有沒必要要的迭代。下面是PHP代碼：
function bubbleSort(&$arr) : void
{
$swapped = false;
$bound = count($arr) - 1;
for ($i = 0, $c = count($arr); $i < $c; $i++) {
for ($j = 0; $j < $bound; $j++) {
if ($arr[$j + 1] < $arr[$j]) {
list($arr[$j], $arr[$j + 1]) = array($arr[$j + 1], $arr[$j]);
$swapped = true;
$newBound = $j;
}
}
$bound = $newBound;
if (!$swapped) break; //沒有發生交換，算法結束
}
}
選擇排序
選擇排序是另外一種基於比較的排序算法，它相似於冒泡排序。最大的區別是它比冒泡排序須要更少的交換。在選擇排序中，咱們首先找到數組的最小/最大項並將其放在第一位。若是咱們按降序排序，那麼咱們將從數組中獲取的是最大值。對於升序，咱們獲取的是最小值。在第二次迭代中，咱們將找到數組的第二個最大值或最小值，並將其放在第二位。持續到咱們把每一個數字放在正確的位置。這就是所謂的選擇排序，選擇排序的僞代碼以下：
procedure selectionSort( A : list of sortable items)
n = length(A)
for i = 1 to n inclusive do
min = i
for j = i + 1 to n inclusive do
if A[j] < A[min] then
min = j
end if
end for
if min != i
swap(a[i], a[min])
end if
end for
end procedure
看上面的算法，咱們能夠發現，在外部循環中的第一次迭代以後，第一個最小項被存儲在第一個位置。在第一次迭代中，咱們選擇第一個項目，而後從剩下的項目（從2到n）找到最小值。咱們假設第一個項目是最小值。咱們找到另外一個最小值，咱們將標記它的位置，直到咱們掃描了剩餘的列表並找到新的最小最小值。若是沒有找到最小值，那麼咱們的假設是正確的，這確實是最小值。以下圖：
正如咱們在前面的圖中看到的，咱們從列表中的第一個項目開始。而後，咱們從數組的其他部分中找到最小值10。在第一次迭代結束時，咱們只交換了兩個地方的值（用箭頭標記）。所以，在第一次迭代結束時，咱們獲得了的數組中獲得最小值。而後，咱們指向下一個數字45，並開始從其位置的右側找到下一個最小的項目，咱們從剩下的項目中找到了20（如兩個箭頭所示）。在第二次迭代結束時，咱們將第二個位置的值和從列表的剩餘部分新找到的最小位置交換。這個操做一直持續到最後一個元素，在過程結束時，咱們獲得了一個排序的列表，下面是PHP代碼的實現。
function selectionSort(&$arr)
{
$count = count($arr);
//重複元素個數-1次
for ($j = 0; $j <= $count - 1; $j++) {
//把第一個沒有排過序的元素設置爲最小值
$min = $arr[$j];
//遍歷每個沒有排過序的元素
for ($i = $j + 1; $i < $count; $i++) {
//若是這個值小於最小值
if ($arr[$i] < $min) {
//把這個元素設置爲最小值
$min = $arr[$i];
//把最小值的位置設置爲這個元素的位置
$minPos = $i;
}
}
//內循環結束把最小值和沒有排過序的元素交換
list($arr[$j], $arr[$minPos]) = [$min, $arr[$j]];
}
}
選擇排序的複雜度
選擇排序看起來也相似於冒泡排序，它有兩個for循環，從0到n。冒泡排序和選擇排序的區別在於，在最壞的狀況下，選擇排序使交換次數達到最大n - 1，而冒泡排序能夠須要 n * n 次交換。在選擇排序中，最佳狀況、最壞狀況和平均狀況具備類似的時間複雜度。
| best time complexity | Ω(n2) |
|---|---|
| worst time complexity | O(n2) |
| average time complexity | Θ(n2) |
| space complexity (worst case) | O(1) |
插入排序
到目前爲止，咱們已經看到了兩種基於比較的排序算法。如今，咱們將探索另外一個排序算法——插入排序。與剛纔看到的其餘兩個排序算法相比，它有最簡單的實現。若是項目的數量較小，插入排序優於冒泡排序和選擇排序。若是數據集很大，就像冒泡排序同樣就變得效率低下。插入排序的工做原理是將數字插入到已排序列表的正確位置。它從數組的第二項開始，並判斷該項是否小於當前值。若是是這樣，它將項目轉移，並將較小的項目存儲在其正確的位置。而後，它移動到下一項，而且相同的原理繼續下去，直到整個數組被排序。
procedure insertionSort(A: list of sortable items)
n length(A)
for i=1 to n inclusive do
key = A[i]
j = i - 1
while j >= 0 and A[j] > key do
A[j+1] = A[j]
j--
end while
A[j + 1] = key
end for
end procedure
假如咱們有下列數組，元素是：20 45 93 67 10 97 52 88 33 92。咱們從第二個項目45開始。如今咱們將從45的左邊第一個項目開始，而後到數組的開頭，看看左邊是否有大於45的值。因爲只有20，因此不須要插入，目前兩項(20, 45)被排序。如今咱們將指針移到93，從它再次開始，比較從45開始，因爲45不大於93，咱們中止。如今，前三項（20, 45, 93）已排序。接下來，對於67，咱們從數字的左邊開始比較。左邊的第一個數字是93，它較大，因此必須移動一個位置。咱們移動93到67的位置。而後，咱們移動到它左邊的下一個項目45。45小於67，不須要進一步的比較。如今，咱們先將93移動到67的位置，而後咱們插入67的到93的位置。繼續如上操做直到整個數組被排序。下圖說明在每一個步驟中使用插入排序的直到徹底排序過程。
function insertionSort(array &$arr)
{
$len = count($arr);
for ($i = 1; $i < $len; $i++) {
$key = $arr[$i];
$j = $i - 1;
while ($j >= 0 && $arr[$j] > $key) {
$arr[$j + 1] = $arr[$j];
$j--;
}
$arr[$j + 1] = $key;
}
}
插入排序的複雜度
插入排序具備與冒泡排序類似的時間複雜度。與冒泡排序的區別是交換的數量遠低於冒泡排序。
| best time complexity | Ω(n) |
|---|---|
| worst time complexity | O(n2) |
| average time complexity | Θ(n2) |
| space complexity (worst case) | O(1) |
排序中的分治思想
到目前爲止，咱們已經瞭解了每次對完整列表進行排序的一些排序算法。咱們每次都須要應對一個比較大的數字集合。咱們能夠設法使數據集合更小，從而解決這個問題。分治思想對咱們有很大幫助。用這種方法，咱們將一個問題分紅兩個或多個子問題或集合，而後在組合子問題的全部結果以得到最終結果。這就是所謂的分而治之方法，分而治之方法可讓咱們有效地解決排序問題，並下降算法的複雜度。最流行的兩種排序算法是合併排序和快速排序，它們應用分治算法對數據進行排序，所以被認爲是最好的排序算法。
歸併排序
正如咱們已經知道的，歸併排序應用分治方法來解決排序問題，咱們用法兩個過程來解決這個問題。第一個是將問題集劃分爲足夠小的問題，以便容易地求解，而後將這些結果結合起來。咱們將用遞歸方法來完成分治部分。下面的圖顯示瞭如何採用分治的方法。
基於前面的圖像，咱們如今能夠開始準備咱們的代碼，它將有兩個部分。
/**
* 歸併排序
* 核心：兩個有序子序列的歸併(function merge)
* 時間複雜度任何狀況下都是 O(nlogn)
* 空間複雜度 O(n)
* 發明人: 約翰·馮·諾伊曼
* 速度僅次於快速排序，爲穩定排序算法，通常用於對整體無序，可是各子項相對有序的數列
* 通常不用於內(內存)排序，通常用於外排序
*/
function mergeSort($arr)
{
$lenght = count($arr);
if ($lenght == 1) return $arr;
$mid = (int)($lenght / 2);
//把待排序數組分割成兩半
$left = mergeSort(array_slice($arr, 0, $mid));
$right = mergeSort(array_slice($arr, $mid));
return merge($left, $right);
}
function merge(array $left, array $right)
{
//初始化兩個指針
$leftIndex = $rightIndex = 0;
$leftLength = count($left);
$rightLength = count($right);
//臨時空間
$combine = [];
//比較兩個指針所在的元素
while ($leftIndex < $leftLength && $rightIndex < $rightLength) {
//若是左邊的元素大於右邊的元素，就將右邊的元素放在單獨的數組，並將右指針向後移動
if ($left[$leftIndex] > $right[$rightIndex]) {
$combine[] = $right[$rightIndex];
$rightIndex++;
} else {
//若是右邊的元素大於左邊的元素，就將左邊的元素放在單獨的數組，並將左指針向後移動
$combine[] = $left[$leftIndex];
$leftIndex++;
}
}
//右邊的數組所有都放入到了返回的數組，而後把左邊數組的值放入返回的數組
while ($leftIndex < $leftLength) {
$combine[] = $left[$leftIndex];
$leftIndex++;
}
//左邊的數組所有都放入到了返回的數組，而後把右邊數組的值放入返回的數組
while ($rightIndex < $rightLength) {
$combine[] = $right[$rightIndex];
$rightIndex++;
}
return $combine;
}
咱們劃分數組，直到它達到1的大小。而後，咱們開始使用合併函數合併結果。在合併函數中，咱們有一個數組來存儲合併的結果。正由於如此，合併排序實際上比咱們迄今所看到的其餘算法具備更大的空間複雜度。
歸併排序的複雜度
因爲歸併排序遵循分而治之的方法，因此咱們必須解決這兩個複雜問題。對於n個大小的數組，咱們首先須要將數組分紅兩個部分，而後合併它們以獲得n個大小的數組。咱們能夠看下面的示意圖
解決每一層子問題須要的時間都是cn，假設一共有l層，那麼總的時間複雜度會是ln。由於一共有logn + 1
層，那麼結果就是 cn(logn + 1)。咱們刪除常數階和線性階，最後的結果能夠得出時間複雜度就是O(nlog2n)。
| best time complexity | Ω(nlogn) |
|---|---|
| worst time complexity | O(nlogn) |
| average time complexity | Θ(nlogn) |
| space complexity (worst case) | O(n) |
快速排序
快速排序是對冒泡排序的一種改進。它的基本思想是：經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另一部分的全部數據都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，以此達到整個數據變成有序序列。
function qSort(array &$arr, int $p, int $r)
{
if ($p < $r) {
$q = partition($arr, $p, $r);
qSort($arr, $p, $q);
qSort($arr, $q + 1, $r);
}
}
function partition(array &$arr, int $p, int $r)
{
$pivot = $arr[$p];
$i = $p - 1;
$j = $r + 1;
while (true) {
do {
$i++;
} while ($arr[$i] < $pivot);
do {
$j--;
} while ($arr[$j] > $pivot);
if ($i < $j) {
list($arr[$i], $arr[$j]) = [$arr[$j], $arr[$i]];
} else {
return $j;
}
}
}
快速排序的複雜度
最壞狀況下快速排序具備與冒泡排序相同的時間複雜度，pivot的選取很是重要。下面是快速排序的複雜度分析。
| best time complexity | Ω(nlogn) |
|---|---|
| worst time complexity | O(n2) |
| average time complexity | Θ(nlogn) |
| space complexity (worst case) | O(logn) |
對於快速排序的優化，有興趣的老鐵能夠點擊這裏查看。
桶排序
桶排序 (Bucket sort)或所謂的箱排序，工做的原理是將數組分到有限數量的桶裏。每一個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排序）。
/**
* 桶排序
* 不是一種基於比較的排序
* T(N, M) = O(M + N) N是帶排序的數據的個數，M是數據值的數量
* 當 M >> N 時，須要考慮使用基數排序
*/
function bucketSort(array &$data)
{
$bucketLen = max($data) - min($data) + 1;
$bucket = array_fill(0, $bucketLen, []);
for ($i = 0; $i < count($data); $i++) {
array_push($bucket[$data[$i] - min($data)], $data[$i]);
}
$k = 0;
for ($i = 0; $i < $bucketLen; $i++) {
$currentBucketLen = count($bucket[$i]);
for ($j = 0; $j < $currentBucketLen; $j++) {
$data[$k] = $bucket[$i][$j];
$k++;
}
}
}
基數排序的PHP實現，有興趣的同窗一樣能夠訪問這個頁面來查看。
快速排序的複雜度
桶排序的時間複雜度優於其餘基於比較的排序算法。如下是桶排序的複雜性
| best time complexity | Ω(n+k) |
|---|---|
| worst time complexity | O(n2) |
| average time complexity | Θ(n+k) |
| space complexity (worst case) | O(n) |
PHP內置的排序算法
PHP有豐富的預約義函數庫，也包含不一樣的排序函數。它有不一樣的功能來排序數組中的項目，你能夠選擇按值仍是按鍵/索引進行排序。在排序時，咱們還能夠保持數組值與它們各自的鍵的關聯。下面是這些函數的總結
| 函數名 | 功能 |
|---|---|
| sort() | 升序排列數組。value/key關聯不保留 |
| rsort() | 按反向/降序排序數組。index/key關聯不保留 |
| asort() | 在保持索引關聯的同時排序數組 |
| arsort() | 對數組進行反向排序並維護索引關聯 |
| ksort() | 按關鍵字排序數組。它保持數據相關性的關鍵。這對於關聯數組是有用的 |
| krsort() | 按順序對數組按鍵排序 |
| natsort() | 使用天然順序算法對數組進行排序，並保持value/key關聯 |
| natcasesort() | 使用不區分大小寫的「天然順序」算法對數組進行排序，並保持value/key關聯。 |
| usort() | 使用用戶定義的比較函數按值對數組進行排序，而且不維護value/key關聯。第二個參數是用於比較的可調用函數 |
| uksort() | 使用用戶定義的比較函數按鍵對數組進行排序，而且不維護value/key關聯。第二個參數是用於比較的可調用函數 |
| uasort() | 使用用戶定義的比較函數按值對數組進行排序，而且維護value/key關聯。第二個參數是用於比較的可調用函數 |
對於sort()、rsort()、ksort()、krsort()、asort()以及 arsort()下面的常量可使用
- SORT_REGULAR - 正常比較單元（不改變類型）
- SORT_NUMERIC - 單元被做爲數字來比較
- SORT_STRING - 單元被做爲字符串來比較
- SORT_LOCALE_STRING - 根據當前的區域（locale）設置來把單元看成字符串比較，能夠用 setlocale() 來改變。
- SORT_NATURAL - 和 natsort() 相似對每一個單元以「天然的順序」對字符串進行排序。 PHP 5.4.0 中新增的。
- SORT_FLAG_CASE - 可以與 SORT_STRING 或 SORT_NATURAL 合併（OR 位運算），不區分大小寫排序字符串。
完整內容
本文引用到的全部算法的實如今這個地址，主要內容是使用PHP語法總結基礎的數據結構和算法。歡迎各位老鐵收藏～
- 1. PHP面試：儘量多的說出你知道的排序算法
- 2. 你知道多少排序算法？
- 3. 程序員，你應該知道的基礎排序算法
- 4. PHP面試題，你知道幾個？
- 5. php的排序算法
- 6. 我所知道的排序算法之歸併排序
- 7. 我所知道的排序算法之插入排序
- 8. PHP的引用，你知道多少？
- 9. PHP的引用，你知道多少
- 10. 你知道和你不知道的選擇排序
- 更多相關文章...
- • PHP 數組排序 - PHP教程
- • ADO 排序 - ADO 教程
- • 算法總結-歸併排序
- • 適用於PHP初學者的學習線路和建議
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. PHP面試：儘量多的說出你知道的排序算法
- 2. 你知道多少排序算法？
- 3. 程序員，你應該知道的基礎排序算法
- 4. PHP面試題，你知道幾個？
- 5. php的排序算法
- 6. 我所知道的排序算法之歸併排序
- 7. 我所知道的排序算法之插入排序
- 8. PHP的引用，你知道多少？
- 9. PHP的引用，你知道多少
- 10. 你知道和你不知道的選擇排序