php实现快速排序的三种方法分享_php实例
写了三种php快速排示例,第一种效率低但最简单最容易理解,第二个是算法导论上提供的单向一次遍历找中值方法,第三种是双向遍历找中值经典快排算法。三组算法实现和比较如下:
方法一:该方法比较直观,但损失了大量的空间为代价,使用了效率较低的merge函数。在三种方法中效率最低。最坏情况下算法退化为(O(n*n))
function quick_sort($array) {
if(count($array) $key = $array[0];
$rightArray = array();
$leftArray = array();
for($i = 1; $i if($array[$i] >= $key) {
$rightArray[] = $array[$i];
} else {
$leftArray[] = $array[$i];
}
}
$leftArray = quick_sort($leftArray);
$rightArray = quick_sort($rightArray);
return array_merge($leftArray, array($key), $rightArray);
}
方法二:该算法来自算法导论,叫作Nico Lomuto方法(感兴趣goole上有详细说明)使用最经典的单方向一次遍历找到中值。
但这种算法在最坏情况下(例如值相同的数组,需要n-1次划分,每一次划分需要O(n) 时间去掉一个元素)最坏情况下为O(n*n)
function quick_sort(&$array, $start, $end) {
if ($start >= $end) return;
$mid = $start;
for ($i = $start + 1; $i if ($array[$i] $mid++;
$tmp = $array[$i];
$array[$i] = $array[$mid];
$array[$mid] = $tmp;
}
}
$tmp = $array[$start];
$array[$start] = $array[$mid];
$array[$mid] = $tmp;
quick_sort($array, $start, $mid - 1);
quick_sort($array, $mid + 1, $end);
}
方法三:该方法基本上是教科书式的常见写法,首先从左向右遍历小于中间元素的跳过,同时从右向左遍历遇到大的元素跳过,然后
如果没有交叉着交换两边值,继续循环,直到找到中间点。注意该方法在处理相同元素的时候,仍旧交换,这样在最坏情况下也有O(nlogn)
效率。但下面的函数中,如果将$array[$right] > $key 改成 $array[$right] >=$key 或将 $array[$left]
情况不但会堕落为O(n*n).而且除了每次比较的消耗外,还会产生n次交互的额外开销。该题还有另外两个考点,针对死记硬背的同学:
1:中间的两个while可否互换。当然不能互换,因为对于快盘需要一个额外的空间保存初始的左值,这样左右互换的时候,先用右边覆盖已经保存
为中值的左值,否则会出现问题。见这句$array[$left] = $array[$right];
2:$array[$right] = $key; 该语句含义可否省略。该句不能省略,大家可以考虑一个极端情况比如两个值的排序(5,2),逐步看下就明白了。
function quick_sort_swap(&$array, $start, $end) {
if($end $key = $array[$start];
$left = $start;
$right = $end;
while($left while($left $key)
$right--;
$array[$left] = $array[$right];
while($left $left++;
$array[$right] = $array[$left];
}
$array[$right] = $key;
quick_sort_swap(&$array, $start, $right - 1);
quick_sort_swap(&$array, $right+1, $end);
}

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



So implementieren Sie die schnelle Sortierung in Python: 1. Definieren Sie eine Funktion namens quick_sort und verwenden Sie die rekursive Methode, um die schnelle Sortierung zu implementieren. 2. Überprüfen Sie die Länge des Arrays. Wenn die Länge kleiner oder gleich 1 ist, geben Sie das Array direkt zurück. Andernfalls wird das erste Element als Pivotelement (Pivot) verwendet und dann wird das Array in zwei Unterarrays unterteilt, die kleiner als das Pivotelement und größer als das Pivotelement sind. 3. Verbinden Sie die beiden Unterarrays und das Pivot-Element, um ein sortiertes Array zu bilden.

Beherrschen Sie die wichtigsten Fähigkeiten und Vorsichtsmaßnahmen der Java-Schnellsortierung. Die Schnellsortierung (QuickSort) ist ein häufig verwendeter Sortieralgorithmus. Seine Kernidee besteht darin, die zu sortierende Sequenz in zwei unabhängige Teile und alle Elemente in einem zu teilen Wenn ein Teil kleiner als das Basiselement ist und alle Elemente des anderen Teils größer als das Basiselement sind, werden die beiden Teile rekursiv sortiert und schließlich eine geordnete Sequenz erhalten. Obwohl die schnelle Sortierung im Durchschnitt eine Zeitkomplexität von O(nlogn) aufweist, degeneriert sie im schlimmsten Fall zu O(nlogn).

Die Java-Implementierung der Schnellsortierung und ihre Leistungsanalyse Die Schnellsortierung (QuickSort) ist ein sehr häufig verwendeter und effizienter Sortieralgorithmus. Es handelt sich um eine Divide-and-Conquer-Idee (Teile und herrsche). Dieser Algorithmus unterteilt ein Array in zwei Unterarrays, sortiert dann die beiden Unterarrays entsprechend und wandelt schließlich das gesamte Array in eine geordnete Sequenz um. Die schnelle Sortierung zeigt eine hervorragende Leistung bei der Verarbeitung großer Datenmengen. Die schnelle Sortierung wird rekursiv implementiert. Die Grundidee ist wie folgt: Wählen Sie eine Basis

Implementierungsprinzip und Optimierung der Java-Schnellsortierfunktion Die Schnellsortierung ist ein effizienter Sortieralgorithmus. Seine Implementierungsidee besteht darin, ein großes Problem mithilfe der Divide-and-Conquer-Methode in mehrere kleine Probleme aufzuteilen und die Teilprobleme rekursiv zu lösen, um schließlich die Gesamtlösung zu erhalten . . Bei der Schnellsortierung müssen wir ein Benchmark-Element auswählen und das Array in zwei Teile teilen, wobei ein Teil kleiner als das Benchmark-Element und der andere Teil größer als das Benchmark-Element ist. Anschließend werden die beiden Teile noch einmal schnell sortiert, bis nur noch ein Element pro Teilproblem vorhanden ist. Schließlich werden die Lösungen aller Teilprobleme kombiniert, um die Arrays zu erhalten

PHP ist eine sehr beliebte Programmiersprache und wird häufig für die Webentwicklung verwendet. In PHP ist Array ein sehr verbreiteter Datentyp und eine sehr leistungsfähige Datenstruktur. Aus diesem Grund bietet PHP viele Array-Funktionen, die Entwicklern bei der Handhabung und Manipulation von Arrays helfen. Dazu gehört die Schnellsortierfunktion, die uns hilft, Arrays schnell zu sortieren. Die Schnellsortierung ist ein gängiger Sortieralgorithmus. Seine Grundidee besteht darin, ein Array durch Vergleich und Austausch in zwei Unterarrays aufzuteilen und diese dann rekursiv durchzuführen

Schnellsortierungsmethode: 1. Erstellen Sie eine Java-Beispieldatei. 2. Implementieren Sie den Schnellsortierungsalgorithmus über die QuickSort-Methode. 3. Wählen Sie ein Element im Array als Pivot aus und teilen Sie das Array in zwei Unterarrays auf Das Element mit dem Pivot enthält das erste Element, und das andere Element enthält das Element, das größer als das Hauptelement ist. Anschließend wird der Schnellsortierungsalgorithmus rekursiv auf die beiden Unterarrays angewendet. 4. Sortieren Sie das Array in der Hauptmethode und geben Sie das Ergebnis aus.

So implementieren Sie den Schnellsortierungsalgorithmus in Java. Die Schnellsortierung (QuickSort) ist ein häufig verwendeter und effizienter Sortieralgorithmus. Seine Grundidee besteht darin, die Divide-and-Conquer-Strategie (Divide and Conquer) anzuwenden. Durch die Auswahl jeweils eines Elements als Benchmark-Wert wird das zu sortierende Array in zwei Teile geteilt, wobei ein Teil kleiner als der Benchmark-Wert ist Der andere Teil ist größer als der Benchmark-Wert, und dann werden die beiden Teile separat verarbeitet und schließlich das gesamte Array sortiert. Im Folgenden stellen wir detailliert vor, wie Sie mithilfe der Java-Sprache eine schnelle Sortierung erreichen

Leistungsanalyse und Vergleich von Java Quick Sort Quick Sort (QuickSort) ist ein vergleichsbasierter Sortieralgorithmus, der aufgrund seiner schnellen Ausführungsgeschwindigkeit und guten Leistung häufig in der tatsächlichen Entwicklung verwendet wird. In diesem Artikel wird eine Leistungsanalyse des Schnellsortierungsalgorithmus in Java durchgeführt und dieser mit anderen gängigen Sortieralgorithmen verglichen. Prinzip des Schnellsortierungsalgorithmus: Die Schnellsortierung übernimmt die Idee der „Teile-und-Herrsche“-Methode. Durch die Aufteilung der zu sortierenden Daten in zwei unabhängige Teile werden die linken und rechten Teilsequenzen rekursiv sortiert, um die Ordnung der gesamten Sequenz zu erreichen.
