php使用递归与迭代实现快速排序示例
代码如下:
/**
* 递归法实现的快速排序
* @param $seq
* @return array
*/
function quicksort($seq)
{
if (count($seq) > 1) {
$k = $seq[0];
$x = array();
$y = array();
$_size = count($seq); //do not use count($seq) in loop for.
for ($i = 1; $i if ($seq[$i] $x[] = $seq[$i];
} else {
$y[] = $seq[$i];
}
}
$x = quicksort($x);
$y = quicksort($y);
return array_merge($x, array($k), $y);
} else {
return $seq;
}
}
/**用迭代实现
* @param $seq
* @return array
*/
function quicksortX(&$seq)
{
$stack = array($seq);
$sort = array();
while ($stack) {
$arr = array_pop($stack);
if(count($arr) if (count($arr) == 1) {
$sort[] = &$arr[0];
}
continue;
}
$k = $arr[0];
$x = array();
$y = array();
$_size = count($arr);
for ($i = 1; $i if ($arr[$i] $x[] = &$arr[$i];
} else {
$y[] = &$arr[$i];
}
}
!empty($y) && array_push($stack, $y);
array_push($stack, array($arr[0]));
!empty($x) && array_push($stack, $x);
}
return $sort;
}
//$testArr = array(5545, 5, 6, 7675, 100, 9, 233, 566, 789, 456, 23, 55, 7, 4, 343, 564, 5, 45657, 8, 998, 9, 34, 34, 55, 6, 5, 6433, 67, 6, 6766, 4, 2, 42, 25634, 34343, 3, 3, 454, 4, 65, 6678, 57, 5455);
for($i=0;$i $testArr[]=mt_rand(0,10000);
}
//var_dump($testArr);
echo count($testArr).'
';
$start=microtime();
echo count(quicksort($testArr)).'
';
echo microtime()-$start.'
';
var_dump(quicksort($testArr));
echo '------------------------------------------------------------------------
';
echo count($testArr).'
';
$start=microtime();
echo count(quicksortX($testArr)).'
';
echo microtime()-$start.'
';
var_dump(quicksortX($testArr));

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Comment implémenter le tri rapide en Python : 1. Définissez une fonction appelée quick_sort et utilisez la méthode récursive pour implémenter le tri rapide ; 2. Vérifiez la longueur du tableau si la longueur est inférieure ou égale à 1, renvoyez directement le tableau. Sinon, sélectionnez le tableau. Le premier élément est utilisé comme élément pivot (pivot), puis le tableau est divisé en deux sous-tableaux plus petits que l'élément pivot et plus grands que l'élément pivot. 3. Connectez les deux sous-tableaux ; et l'élément pivot pour former un tableau trié.

Maîtrisez les compétences et précautions clés du tri rapide Java (QuickSort) est un algorithme de tri couramment utilisé. Son idée principale est de diviser la séquence à trier en deux parties indépendantes en sélectionnant un élément de référence et tous les éléments en un seul. partie sont égales. est inférieur à l'élément de base et tous les éléments de l'autre partie sont supérieurs à l'élément de base, puis les deux parties sont triées de manière récursive et finalement une séquence ordonnée est obtenue. Bien que le tri rapide ait une complexité temporelle de O(nlogn) dans le cas moyen, il dégénère en O(nlogn) dans le pire des cas.

Implémentation Java du tri rapide et son analyse des performances Le tri rapide (QuickSort) est un algorithme de tri très couramment utilisé et efficace. Il s'agit d'une idée diviser pour mieux régner (Divide and Conquer). Cet algorithme divise un tableau en deux sous-tableaux, puis trie respectivement les deux sous-tableaux et transforme enfin le tableau entier en une séquence ordonnée. Le tri rapide affiche d'excellentes performances lors du traitement de données à grande échelle. Le tri rapide est implémenté de manière récursive. L'idée de base est la suivante : Choisir une base.

Principe de mise en œuvre et optimisation de la fonction de tri rapide Java Le tri rapide est un algorithme de tri efficace. Son idée de mise en œuvre est de diviser un gros problème en plusieurs petits problèmes via la méthode diviser pour mieux régner, et de résoudre les sous-problèmes de manière récursive pour finalement obtenir la solution globale. . Lors d'un tri rapide, nous devons sélectionner un élément de référence et diviser le tableau en deux parties, une partie est plus petite que l'élément de référence et l'autre partie est plus grande que l'élément de référence. Les deux parties sont ensuite rapidement triées à nouveau jusqu'à ce qu'il n'y ait qu'un seul élément par sous-problème. Enfin, les solutions de tous les sous-problèmes sont combinées pour obtenir le résultat du tableau.

Méthode de tri rapide : 1. Créez un exemple de fichier Java ; 2. Implémentez l'algorithme de tri rapide via la méthode quickSort 3. Sélectionnez un élément du tableau comme pivot (pivot) et divisez le tableau en deux sous-tableaux, un. contenant le pivot L'élément avec l'élément le plus petit est l'élément le plus petit, et l'autre contient l'élément qui est plus grand que l'élément pivot, puis l'algorithme de tri rapide est appliqué de manière récursive aux deux sous-tableaux 4. Triez le tableau en ; la méthode principale et afficher le résultat.

PHP est un langage de programmation très populaire et largement utilisé pour le développement Web. En PHP, le tableau est un type de données très courant et une structure de données très puissante. Pour cette raison, PHP fournit de nombreuses fonctions de tableau pour aider les développeurs à gérer et manipuler les tableaux. Cela inclut la fonction de tri rapide, qui nous aide à trier rapidement les tableaux. Le tri rapide est un algorithme de tri courant. Son idée de base est de diviser un tableau en deux sous-tableaux, l'un plus petit que l'autre, par comparaison et échange, puis de manière récursive.

Comment utiliser Java pour implémenter un algorithme de tri rapide Le tri rapide (QuickSort) est un algorithme de tri couramment utilisé et efficace. Son idée de base est d'adopter la stratégie diviser pour régner (Divide and Conquer). En sélectionnant un élément à la fois comme valeur de référence, le tableau à trier est divisé en deux parties, une partie est plus petite que la valeur de référence et l'autre partie est plus grande que la valeur de référence, puis les deux parties sont traitées séparément et trient finalement l'ensemble du tableau. Ci-dessous, nous présenterons en détail comment utiliser le langage Java pour réaliser un tri rapide

Analyse des performances et comparaison de Java Quick Sort Quick Sort (QuickSort) est un algorithme de tri basé sur la comparaison qui est largement utilisé dans le développement réel en raison de sa vitesse d'exécution rapide et de ses bonnes performances. Cet article effectuera une analyse des performances de l'algorithme de tri rapide en Java et le comparera avec d'autres algorithmes de tri courants. Principe de l'algorithme de tri rapide Le tri rapide adopte l'idée de la méthode diviser pour régner. En divisant les données à trier en deux parties indépendantes, les sous-séquences gauche et droite sont triées de manière récursive, de manière à obtenir l'ordre de l'ensemble de la séquence.
