Utilisez PHP pour écrire plusieurs programmes d'algorithmes de tri courants

Les algorithmes de tri sont souvent rencontrés en programmation. Cet article utilisera PHP pour implémenter plusieurs algorithmes de tri courants.

1. Le tri à bulles

Le tri à bulles est le plus simple à comprendre, mais sa complexité temporelle (O(n^2)) est également l'une des plus importantes. Le code d'implémentation est le suivant :

function bubbleSort($arr) {
 $len = count($arr);
 for ($i = 0; $i < $len; $i++) {
  // 遍历i后面的元素，只要该元素小于当前元素，就把较小的往前冒泡
  for ($j = $i + 1; $j < $len; $j++) {
if ($arr[$i] > $arr[$j]) {
 $t = $arr[$i];
 $arr[$i] = $arr[$j];
 $arr[$j] = $t;
}
  }
 }
 return $arr;
}
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

2. Tri par sélection

Le tri par sélection est relativement simple à comprendre et la complexité temporelle est O(n^2). 🎜>

3, Tri par insertion

function selectSort($arr) {
 $len = count($arr);
 for ($i = 0; $i < $len; $i++) {
  $minIndex = $i;
  // 找出i后面最小的元素与当前元素交换
  for ($j = $i + 1; $j < $len; $j++) {
if ($arr[$j] < $arr[$minIndex]) {
 $minIndex = $j;
}
  }
  if ($minIndex != $i) {
$t = $arr[$i];
$arr[$i] = $arr[$minIndex];
$arr[$minIndex] = $t;
  }
 }
 return $arr;
}
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

Je pense que le tri par insertion est quelque peu similaire au tri à bulles, et la complexité temporelle est également O(n^2). Le code d'implémentation est le suivant :

.

4. Tri Hill

function insertSort($arr) {
 $len = count($arr);
 for ($i = 1; $i < $len; $i++) {
  if ($arr[$i] < $arr[$i - 1]) {
$t = $arr[$i];
$j = $i - 1;
// 如果当前元素大于前一个元素，就往前挪
while ($j >= 0 && $t < $arr[$j]) {
 $arr[$j + 1] = $arr[$j];
 $j--;
}
$arr[$j + 1] = $t;
  }
 }
 return $arr;
}
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

Le tri Hill peut en fait être compris comme une version optimisée du tri par insertion. Son efficacité est liée à l'incrément. est un algorithme de tri instable, sa complexité temporelle est comprise entre O(nlogn) et O(n^2), le code d'implémentation est le suivant :

5. Tri par tas

function shellSort($arr) {
 $len = count($arr);
 $stepSize = floor($len / 2);
 while ($stepSize >= 1) {
  for ($i = $stepSize; $i < $len; $i++) {
if ($arr[$i] < $arr[$i - $stepSize]) {
 $t = $arr[$i];
 $j = $i - $stepSize;
 while ($j >= 0 && $t < $arr[$j]) {
  $arr[$j + $stepSize] = $arr[$j];
  $j -= $stepSize;
 }
 $arr[$j + $stepSize] = $t;
}
  }
  // 缩小步长，再进行插入排序
  $stepSize = floor($stepSize / 2);
 }
 return $arr;
}
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

Le tri par tas est un algorithme de tri efficace, sa complexité temporelle est O(nlogn). Le principe est le suivant : convertissez d'abord le tableau en un tas maximum, puis échangez le premier élément avec le i-ème élément, puis convertissez les i-1 éléments restants en un tas maximum, puis échangez le premier élément avec le i-ème élément. . 1 élément est échangé, et ainsi de suite. Le code d'implémentation est le suivant : function heapSort($arr) {

6. Tri rapide

 $len = count($arr);
 // 先建立最大堆
 for ($i = floor(($len - 1) / 2); $i >= 0; $i--) {
  $s = $i;
  $childIndex = $s * 2 + 1;
  while ($childIndex < $len) {
// 在父、左子、右子中 ，找到最大的
if ($childIndex + 1 < $len && $arr[$childIndex] < $arr[$childIndex + 1]) $childIndex++;
if ($arr[$s] < $arr[$childIndex]) {
 $t = $arr[$s];
 $arr[$s] = $arr[$childIndex];
 $arr[$childIndex] = $t;
 $s = $childIndex;
 $childIndex = $childIndex * 2 + 1;
} else {
 break;
}
  }
 }
 // 从最后一个元素开始调整
 for ($i = $len - 1; $i > 0; $i--) {
  $t = $arr[$i];
  $arr[$i] = $arr[0];
  $arr[0] = $t;
  // 调整第一个元素
  $s = 0;
  $childIndex = 1;
  while ($childIndex < $i) {
// 在父、左子、右子中 ，找到最大的
if ($childIndex + 1 < $i && $arr[$childIndex] < $arr[$childIndex + 1]) $childIndex++;
if ($arr[$s] < $arr[$childIndex]) {
 $t = $arr[$s];
 $arr[$s] = $arr[$childIndex];
 $arr[$childIndex] = $t;
 $s = $childIndex;
 $childIndex = $childIndex * 2 + 1;
} else {
 break;
}
  }
 }
 return $arr;
} 
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

Le tri rapide est également un algorithme de tri efficace, et sa complexité temporelle est également O( nlogn). Le principe est le suivant : sélectionnez un élément de base, puis placez les éléments du tableau qui sont plus petits que cet élément à gauche de l'élément de base, et les éléments qui sont plus grands que lui sont placés à droite de l'élément de base. Continuez ensuite la même opération des deux côtés. Le code est le suivant :

7. Tri par fusion

function quickSort($arr) {
 $len = count($arr);
 quickSortRecursion($arr, 0, $len - 1);
 return $arr;
}
 
function quickSortRecursion(&$arr, $begin, $end) {
 if ($begin < $end) {
  $left = $begin;
  $right = $end;
  $temp = $arr[$begin];// $temp为基准元素
  // 把小于$temp的元素放到$temp左边，大于它的放在右边
  while ($left < $right) {
while ($left < $right && $arr[$right] >= $temp) $right--;
if ($left < $right) {
 $arr[$left++] = $arr[$right];
}
while ($left < $right && $arr[$left] <= $temp) $left++;
if ($left < $right) {
 $arr[$right--] = $arr[$left];
}
  }
  $arr[$left] = $temp;
  // 把数组分成两部分，递归调用该函数
  quickSortRecursion($arr, $begin, $left - 1);
  quickSortRecursion($arr, $left + 1, $end);
 }
 return $arr;
}
 
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

La complexité temporelle du tri par fusion est également O(nlogn). Le principe est le suivant : pour deux tableaux triés, parcourir respectivement les deux tableaux, obtenir les éléments les plus petits et les insérer dans le nouveau tableau, puis le nouveau tableau sera également trié. Le code est le suivant :

Cet article explique en détail l'utilisation de programmes PHP pour implémenter l'algorithme de tri. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois.

function mergeSort($arr) {
 $len = count($arr);
 $arr = mergeSortRecursion($arr, 0, $len - 1);
 return $arr;
}
function mergeSortRecursion(&$arr, $begin, $end) {
 if ($begin < $end) {
  $mid = floor(($begin + $end) / 2);
  // 把数组不断拆分，只到只剩下一个元素，对于一个元素的数组，一定是排序好的
  mergeSortRecursion($arr, $begin, $mid);
  mergeSortRecursion($arr, $mid + 1, $end);
  $i = $begin;
  $j = $mid + 1;
  $k = 0;
  $temp = array();
  // 开始执行归并，遍历两个数组，从它们里面取较小的元素插入到新数组中
  while ($i <= $mid && $j <= $end) {
if ($arr[$i] < $arr[$j]) {
 $temp[$k++] = $arr[$i++];
} else {
 $temp[$k++] = $arr[$j++];
}
  }
  while ($i <= $mid) {
$temp[$k++] = $arr[$i++];
  }
  while ($j <= $end) {
$temp[$k++] = $arr[$j++];
  }
  for ($i = 0; $i < $k; $i++) {
$arr[$i + $begin] = $temp[$i];
  }
 }
 return $arr;
}
$arr = [3,1,13,5,7,11,2,4,14,9,15,6,12,10,8];
print_r(bubbleSort($arr));

Recommandations associées :

Comment PHP détermine-t-il s'il s'agit d'une requête AJAX ?

Solutions à l'avertissement date() signalé par le programme PHP

Comment résoudre les problèmes de concurrence dans le développement PHP Découverte de cas de méthodes de mise en œuvre

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!