Schnelle Sortierung in Java erklärte

Quick Sort, ebenfalls als QuickSort geschrieben, ist ein Listen-Sortierschema, das das Divide-and-Conquer-Paradigma verwendet. Es gibt verschiedene Programme für schnelle Sortier. Vor der Erläuterung der schnellen Sorte muss der Leser die Konvent.

Halbierungskonvention

Wenn die Anzahl der Elemente in einer Liste gleichmäßig ist, ist die Halbierung der Liste die erste Hälfte der Liste der ersten Hälfte, und die zweite Hälfte der Liste ist die zweite Hälfte. Das mittlere (mittlere) Element der gesamten Liste ist das letzte Element der ersten Liste. Dies bedeutet, dass der mittlere Index Länge / 2 - 1 ist, da die Indexzählung von Null beginnt. Länge ist die Anzahl der Elemente in der Liste. Wenn beispielsweise die Anzahl der Elemente 8 beträgt, hat die erste Hälfte der Liste 4 Elemente und die zweite Hälfte der Liste auch 4 Elemente. Das ist gut. Da die Indexzählung von 0 beginnt, beträgt der mittlere Index 3 = 8/2 - 1.

Was ist mit dem Fall, wenn die Anzahl der Elemente in der Liste oder der Unterliste ungerade ist? Zu Beginn ist die Länge immer noch durch 2 geteilt. Nach Übereinkommen ist die Anzahl der Elemente in der ersten Hälfte dieser Division Länge / 2 + 1/2. Die Indexzählung beginnt von Null. Der mittlere Index ist nach Länge / 2 - 1/2 gegeben. Dies gilt als mittlere Amtszeit durch Konvention. Wenn beispielsweise die Anzahl der Elemente in einer Liste 5 beträgt, beträgt der mittlere Index 2 = 5/2 - 1/2. Und in der ersten Hälfte der Liste gibt es drei Elemente und zwei Elemente in der zweiten Hälfte. Das mittlere Element der gesamten Liste ist das dritte Element bei Index 2, das der mittlere Index ist, da die Indexzählung von 0 beginnt.

Auf diese Weise ist Teilung ein Beispiel für die ganzzahlige Arithmetik.

Median von drei Werten

Frage: Was ist der Median der Sequenz:

C b a

Lösung:
Ordnen Sie die Liste in aufsteigender Reihenfolge an:

A b c

Der mittlere Begriff B ist der Median. Es ist die Größe, die zwischen den beiden anderen Größen liegt.

Auf der Suche nach dem Median in einer Liste ist nicht diese Art. Zum Beispiel kann in einer Liste von 19 Elementen, die ungeortiert sind, der Median für das erste Element, das mittlere Element und das letzte Element erforderlich sein. Diese drei Werte sind möglicherweise nicht in aufsteigender Reihenfolge; und so müssen ihre Indizes berücksichtigt werden.

Mit schneller Art sind der Median für die gesamte Liste und die Unterlisten erforderlich. Der Pseudocode, der nach dem Median von drei in einer Liste (Array) ausgerichteten Werten sucht, lautet:

Mitte: = ⌊ (niedrig + hoch) / 2⌋
Wenn arr [Mid] < arr[low]
Swap arr [niedrig] mit arr [Mid]
Wenn arr [hoch] < arr[low]
Swap arr [niedrig] mit arr [hoch]
Wenn arr [Mid] < arr[high]
Swap arr [Mid] mit arr [hoch]
Pivot: = arr [hoch]

Der Begriff „arr“ bedeutet Array. Dieses Code -Segment sucht nach dem Median und sortiert auch eine Sortierung. Dieses Codesegment sieht einfach aus, kann aber sehr verwirrend sein. Achten Sie also auf die folgende Erklärung:

Die Sortierung in diesem Tutorial erstellt eine Liste, in der der erste Wert der kleinste Wert ist, und der letzte Wert ist der größte Wert. Mit dem Alphabet ist a weniger als z.

Hier ist der Drehpunkt der resultierende Median. Niedrig ist der niedrigste Index der Liste oder Unterliste (nicht unbedingt für den niedrigsten Wert); Hoch ist der höchste Index der Liste oder Unterliste (nicht unbedingt für den höchsten Wert), und Mitte ist der herkömmliche Mittelindex (nicht unbedingt für den mittleren Wert der gesamten Liste).

Der zu erhaltene Median liegt also zwischen dem Wert des niedrigsten Index, dem Wert des mittleren Index und dem Wert des höchsten Index.

Im Code wird der herkömmliche Mittelindex zuerst erhalten. Zu diesem Start ist die Liste ungewöhnlich. Der Vergleich und einige Umlagerung in der aufsteigenden Reihenfolge der drei Werte sollen gleichzeitig stattfinden. Der erste If-Statement vergleicht den Wert für den niedrigsten Index und den des mittleren Index. Wenn der des mittleren Index geringer ist als der des niedrigsten Index, dann tauschen die beiden Wertepositionen aus. Dies beginnt zu sortieren und ändert die Anordnung von Werten in der Liste oder der Unterliste. Der zweite If-Statement vergleicht den Wert für den höchsten Index und den des niedrigsten Index. Wenn der des höchsten Index geringer ist als der des niedrigsten Index, tauschen die beiden Wertepositionen aus. Dies führt zu einer Sortierung und Änderung der Werteanordnung in der Liste oder der Unterliste. Der dritte If-Statement vergleicht den Wert für den mittleren Index und den des höchsten Index. Wenn der des höchsten Index geringer ist als der mittlere Index, tauschen die beiden Wertepositionen aus. Hier kann auch eine Sortierung oder Neuordnung auftreten. Diese dritte If-Kondition ist nicht wie bei den beiden vorherigen.

Am Ende dieser drei Swaps wäre der mittlere Wert der drei fraglichen Werte ein [hoch], dessen ursprünglicher Inhalt im Codesegment möglicherweise geändert worden sein könnte. Betrachten Sie beispielsweise die unsortierte Sequenz:

C b a

Wir wissen bereits, dass der Median B ist. Dies sollte jedoch nachgewiesen werden. Das Ziel hier ist es, den Median dieser drei Werte mit dem obigen Codesegment zu erhalten. Die erste wenn. Wenn b kleiner als C ist, müssen die Positionen von B und C getauscht werden. B ist weniger als C, daher wird die neue Anordnung:

B c a

Beachten Sie, dass die Werte für den niedrigsten Index und den mittleren Index geändert wurden. Der zweite If-Statement vergleicht a und b. Wenn a weniger als B ist, müssen die Positionen von A und B getauscht werden. A ist weniger als B, daher wird die neue Anordnung:

A c b

Beachten Sie, dass die Werte für den höchsten Index und den niedrigsten Index geändert wurden. Der dritte if-statement vergleicht c und b. Wenn C kleiner als B ist, müssen die Positionen von C und B getauscht werden. C ist nicht weniger als B, daher findet kein Austausch statt. Die neue Arrangement bleibt wie die vorherige, dh:

A c b

B ist der Median, das ist A [High], und es ist der Drehpunkt. Der Drehpunkt wird also am extremen Ende der Liste oder der Unterliste geboren.

Die Tauschfunktion

Eine weitere Funktion, die von Schnellsorten benötigt wird, ist die Tauschfunktion. Die Tauschfunktion tauscht die Werte von zwei Variablen aus. Der Pseudocode für die Tauschfunktion lautet:

Swap (x, y) definieren
Temp: = x
x: = y
y: = tempor

Hier beziehen sich X und Y auf die tatsächlichen Werte und nicht auf die Kopien.

Die Sortierung in diesem Artikel erstellt eine Liste, in der der erste Wert der kleinste Wert ist, und der letzte Wert ist der größte Wert.

Artikelinhalt

• Schneller Sortieralgorithmus
• Ein Partitionspseudocode
• Illustration von schneller Art
• Java -Codierung
• Abschluss

Schneller Sortieralgorithmus

Die normale Möglichkeit, eine unsortierte Liste zu sortieren, besteht darin, die ersten beiden Werte zu berücksichtigen. Wenn sie nicht in Ordnung sind, geben Sie sie in Ordnung ein. Betrachten Sie als nächstes die ersten drei Werte. Scannen Sie die ersten beiden, um festzustellen, wo der dritte Wert passt, und passen Sie ihn angemessen an. Betrachten Sie dann die ersten vier Werte. Scannen Sie die ersten drei Werte, um festzustellen, wo der vierte Wert passt, und passen Sie ihn angemessen an. Fahren Sie mit diesem Verfahren fort, bis die gesamte Liste sortiert ist.

Dieses Verfahren, auch als Brute-Force-Sortierung bezeichnet, im Computerprogrammierungsprachler ist zu langsam. Der Schnellsortalgorithmus ist mit einer viel schnelleren Prozedur verbunden.

Die Schritte für den QuickSort -Algorithmus sind wie folgt:

1. Stellen Sie sicher.
2. Erhalten Sie einen geschätzten zentralen Wert für die Liste, der als Pivot bezeichnet wird. Der Median ist wie oben beschrieben eine Möglichkeit, den Drehpunkt zu erhalten. Verschiedene Wege sind mit ihren Vor- und Nachteilen verbunden. - Später sehen.
3. Partition der Liste. Dies bedeutet, dass Sie den Drehpunkt in die Liste legen. Auf diese Weise sind alle Elemente links geringer als der Drehwert, und alle Elemente rechts sind größer oder gleich dem Pivot -Wert. Es gibt verschiedene Wege der Partitionierung. Jede Partitionsmethode enthält ihre Vor- und Nachteile. Die Aufteilung teil.
4. Wiederholen Sie die Schritte 1, 2 und 3 rekursiv für die neuen Unterlistenpaare, die auftreten, bis die gesamte Liste sortiert ist. Dies erobert sich im Divide-and-Conquer-Paradigma.

Der schnelle Sortierpseudocode lautet:

Algorithmus Quicksort (arr, niedrig, hoch) ist
Ich fließe < high then
Drehzahl (niedrig, hoch)
P: = Partition (arr, niedrig, hoch)
Quicksort (arr, niedrig, p - 1)
Quicksort (arr, p + 1, hoch)

Ein Partitionspseudocode

Der in diesem Tutorial verwendete Partitionspseudocode lautet:

Algorithmus -Partition (arr, niedrig, hoch) ist
Pivot: = arr [hoch]
I: = niedrig
J: = hoch
Tun
Tun
++ich
während (arr [i] < pivot)
Tun
--J
while (arr [j]> pivot)
wenn ich < j)
Tauschen Sie arr [i] mit arr [j]
während ich < j)
Swap arr [i] mit arr [hoch]
Rückkehr i

In der Abbildung von schneller Sortierung unten wird dieser Code verwendet:

Illustration von schneller Art

Betrachten Sie die folgende ungewöhnliche Liste (Array) alphabetischer Buchstaben:

Q w e r t y u i o p

Durch die Inspektion lautet die sortierte Liste:

E i o p q r t u w y

Die sortierte Liste wird nun unter Verwendung der oben genannten Algorithmus- und Pseudocode -Segmente aus der ungeortierten Liste nachgewiesen:

Q w e r t y u i o p

Der erste Drehpunkt wird aus arr [0] = q, arr [4] = t und arr [9] = p bestimmt und wird als q identifiziert und rechts von der Liste platziert. Die Liste mit jeder Sortierung von Pivot -Funktionen wird also:

P w e r t y u i o q

Der aktuelle Drehpunkt ist q. Das Pivot -Verfahren hat eine kleine Sortierung durchgeführt und P an der ersten Position platziert. Die resultierende Liste muss neu angeordnet werden (partitioniert), sodass alle Elemente links einen geringeren Wert haben, dann der Drehpunkt und alle Elemente rechts vom Drehpunkt sind gleich oder größer als der Drehzahl. Der Computer kann nicht durch Inspektion verteilt werden. Daher verwendet dies mit den Indizes und dem obigen Partitionalgorithmus.

Die niedrigen und hohen Indizes sind jetzt 0 und 9. Der Computer beginnt damit, aus dem Index 0 zu scannen, bis er einen Index erreicht, dessen Wert gleich oder größer als der Drehpunkt ist und dort vorübergehend stoppt. Es wird auch vom hohen (rechten) Ende, Index 9, gescannt, bis er einen Index erreicht. Dies bedeutet zwei Stop -Positionen. Wenn ich die inkrementelle Indexvariable von niedrig noch nicht gleich oder größer ist als die abnehmende Indexvariable, j von hoch, werden diese beiden Werte ausgetauscht. In der aktuellen Situation hörte das Scannen von beiden Enden bei W und O auf. Die Liste wird also:

P o e r t y u i w q

Der Drehpunkt ist immer noch q. Das Scannen in entgegengesetzte Richtungen geht weiter und stoppt entsprechend. Wenn ich noch nicht gleich oder größer als J ist, werden die beiden Werte, bei denen das Scannen von beiden Enden gestoppt wird. Diesmal hörte das Scannen von beiden Enden bei R und I auf. Die Anordnung der Liste wird also:

P o e i t y y y y y y y y y q

Der Drehpunkt ist immer noch q. Das Scannen in entgegengesetzte Richtungen geht weiter und stoppt entsprechend. Wenn ich noch nicht gleich oder größer als J ist, werden die beiden Werte, bei denen das Scannen gestoppt ist, getauscht. Diesmal hörte das Scannen von beiden Enden bei T für mich und ich nach J. Ich und J haben sich getroffen oder gekreuzt. Es kann also keinen Tausch geben. Die Liste bleibt die gleiche wie:

P o e i t y y y y y y y y y q

Zu diesem Zeitpunkt muss der Pivot, Q, in seine endgültige Position in der Sortierung platziert werden. Dies geschieht durch Tausch von arr [i] mit arr [hoch], t und q tauscht. Die Liste wird:

P o e i q y u r w t

Zu diesem Zeitpunkt ist die Partitionierung für die gesamte Liste beendet. Der Pivot = q hat seine Rolle gespielt. Es gibt jetzt drei Unterlisten, nämlich:

P o e i q y u r w t

Die Teilung ist Aufteilung und Eroberung (Sortierung) im Paradigma. Q befindet sich in der richtigen Sortierposition. Jedes Element links von Q ist kleiner als Q, und jedes Element rechts von Q ist größer als Q. Die linke Liste ist jedoch noch nicht sortiert. und die richtige Liste ist noch nicht sortiert. Die gesamte schnelle Sortierfunktion muss rekursiv aufgerufen werden, um die linke Unterliste und die rechte Unterliste zu sortieren. Dieses Erinnern von schneller Art muss fortgesetzt werden. Neue Unterlisten entwickeln sich, bis die gesamte Originalliste vollständig sortiert ist. Für jedes Rückruf der schnellen Sortierfunktion wird die linke Unterliste zuerst beachtet, bevor die entsprechende rechte Unterliste betroffen ist. Für jede Unterliste muss ein neuer Drehpunkt erhalten werden.

Für die Unterliste:

P o e i

Der Drehpunkt (Median) für p, o und ich werden bestimmt. Der Drehpunkt wäre o. Für diese Unterliste und in Bezug auf die vollständige Liste ist der neue arr [niedrig] arr [0] und der neue arr [hoch] ist der letzte arr [i-1] = arr [4-1] = arr [3], wo ich der endgültige Pivot -Index aus der vorherigen Partition ist. Nachdem die Funktion pivot () aufgerufen wurde, der neue Pivot -Wert Pivot = o. Verwechseln Sie nicht zwischen der Pivot -Funktion und dem Pivot -Wert. Die Drehfunktion kann eine kleine Sortierung ausführen und den Drehpunkt nach rechts der Unterliste platzieren. Diese Unterliste wird,

Ich p e o

Mit diesem Schema endet der Drehpunkt immer am rechten Ende der Unterliste oder der Liste nach seinem Funktionsaufruf. Das Scannen von beiden Enden beginnt von arr [0] und arr [3], bis ich und j treffen oder kreuzen. Der Vergleich erfolgt mit Pivot = o. Die ersten Stopps sind bei p und e. Sie werden ausgetauscht und die neue Unterliste wird:

I e p o

Das Scannen von beiden Enden geht weiter, und die neuen Stopps sind bei P für i und e für J. Jetzt haben ich und J getroffen oder kreuzen. Die Unterliste bleibt also dasselbe wie:

I e p o

Die Aufteilung einer Unterliste oder Liste endet, wenn der Drehpunkt in ihre endgültige Position gebracht wurde. Die neuen Werte für arr [i] und arr [hoch] werden also getauscht. Das heißt, P und O werden getauscht. Die neue Unterliste wird:

I e o p

O befindet sich jetzt in der endgültigen Position für die gesamte Liste. Seine Rolle als Drehzahl ist beendet. Die Unterliste ist derzeit in drei weitere Listen aufgeteilt, nämlich:

I e o p

Zu diesem Zeitpunkt muss eine schnelle Art der ersten rechten Unterliste aufgerufen werden. Es wird jedoch nicht genannt. Stattdessen wird es notiert und reserviert, später aufgerufen zu werden. Da die Aussagen der Partitionierungsfunktion aus der Spitze der Funktion ausgeführt wurden, ist es die schnelle Sortierung für die linke Unterliste, die jetzt aufgerufen werden muss (nachdem Pivot () aufgerufen wurde). Es wird für die Liste gefordert:

Ich e

Es wird mit der Suche nach dem Median von I und E beginnen. Hier, arr [niedrig] = i, arr [Mid] = i und arr [hoch] = e. Also sollte der Median, den Drehpunkt, durch den Pivot -Algorithmus als, i bestimmt werden. Das obige Pivot -Pseudocode bestimmt jedoch den Drehpunkt als e. Dieser Fehler tritt hier auf, da das obige Pseudocode für drei Elemente und nicht zwei bestimmt ist. In der folgenden Implementierung gibt es eine gewisse Anpassung an den Code. Die Unterliste wird,

E i

Der Drehpunkt endet immer am rechten Ende der Unterliste oder der Liste nach seinem Funktionsaufruf. Das Scannen von beiden Enden beginnt von arr [0] und arr [1] exklusiv, bis ich und J treffen oder kreuzen. Der Vergleich erfolgt mit Pivot = i. Die erste und nur Stopps sind bei i und e: bei i for I und bei e für j. Jetzt haben ich und J getroffen oder gekreuzt. Die Unterliste bleibt also gleich:

E i

Die Aufteilung einer Unterliste oder Liste endet, wenn der Drehpunkt in ihre endgültige Position gebracht wurde. Die neuen Werte für arr [i] und arr [hoch] werden also getauscht. Es passiert hier, dass arr [i] = i und arr [hoch] = i. Der gleiche Wert wird also mit sich selbst getauscht. Die neue Unterliste wird:

E i

Ich bin jetzt in seiner endgültigen Position für die gesamte Liste. Seine Rolle als Drehzahl ist beendet. Die Unterliste wird jetzt in zwei weitere Listen unterteilt, die sind,

E i

Jetzt waren die Drehbücher bisher Q, O und ich. Pivots enden an ihren endgültigen Positionen. Eine Unterliste eines einzelnen Elements, wie das obige P, endet ebenfalls an seiner endgültigen Position.

Zu diesem Zeitpunkt wurde die erste linke Unterliste vollständig sortiert. Und das Sortierverfahren ist jetzt bei:

E i o p q y u r w t

Die erste rechte Unterliste:

Y u r w t

muss noch sortiert werden.

Eroberung der ersten rechten Unterliste
Denken Sie daran, dass der schnelle Sortierruf für die erste rechte Unterliste notiert und reserviert wurde, anstatt hingerichtet zu werden. Zu diesem Zeitpunkt wird es ausgeführt. Und so bleibt der neue arr [niedrig] = arr [5] = arr [qpivotindex+1], und der neue arr [hoch] bleibt arr [9]. Eine ähnliche Aktivität, die für die erste linke Unterliste stattgefunden hat, wird hier stattfinden. Und diese erste rechte Unterliste ist sortiert nach:

R t u w y

Und die ursprüngliche unsortierte Liste wurde sortiert nach:

E i o p q r t u w y

Java -Codierung

Wenn Sie den Algorithmus in Java einsetzen. Vergessen Sie nicht, dass es in der Klasse eine Main () -Methode geben muss.

Die Pivot () -Methode

Die Java pivot () -Methode, die den Wert, Pivot, zurückgibt, sollte sein:

void pivot (char arr [], int niedrig, int hoch)
int Mid = (niedrig + hoch) / 2;
if (arr [Mid] < arr[low])
Swap (arr, niedrig, mittel);
if (arr [hoch] < arr[low])
Swap (arr, niedrig, hoch);
if ((hoch - niedrig)> 2)
if (arr [Mid] < arr[high])
Swap (arr, Mid, High);

Die SWAP () -Methode

Die SWAP () -Methode sollte sein:

Hohlraumtausch (char arr [], int x, int y)
char temp = arr [x];
arr [x] = arr [y];
arr [y] = temp;

Die methode quicksort ()

Die QuickSort () -Methode sollte sein:

void Quicksort (char arr [], int niedrig, int hoch)
Ich fließe < high)
Pivot (arr, niedrig, hoch);
int p = partition (arr, niedrig, hoch);
QuickSort (arr, niedrig, p - 1);
QuickSort (arr, p + 1, hoch);

Die Partition () -Methode

Die Partition () -Methode sollte sein:

int partition (char arr [], int niedrig, int hoch)
char pivot = arr [hoch];
int i = niedrig;
int j = hoch;
Tun
Tun
++ich;
während (arr [i] < pivot);
Tun
--J;
während (arr [j]> pivot);
wenn ich < j)
tauschen (arr, ich, j);
während ich < j);
tauschen (arr, ich, hoch);
kehre I zurück;

Die main () Methode

Die main () -Methode kann sein:

public static void main (String [] args)
char arr [] = 'q', 'w', 'e', ​​'r', 't', 'y', 'u', 'i', 'o', 'p';
Theclass Quicksort = new theclass ();
Schnelle Sorte.QuickSort (arr, 0, 9);
System.aus.println ("Die sortierten Elemente:");
für (int i = 0; i<10; i++)
System.aus.print (arr [i]); System.aus.drucken(");

System.aus.println ();

Alle oben genannten Methoden können in eine Klasse gestellt werden.

Abschluss

Schnelle Sortierung ist ein Sortieralgorithmus, der das Divide-and-Conquer-Paradigma verwendet. Es beginnt mit der Aufteilung einer unsortierten Liste in zwei oder drei Unterlisten. In diesem Tutorial hat Quick Sort eine Liste in drei Unterlisten unterteilt: eine linke Unterliste, eine mittlere Liste eines einzelnen Elements und eine rechte Unterliste. Die Eroberung der schnellen Sortierung spaltet eine Liste oder eine Unterliste beim Sortieren mit einem Pivot-Wert. Dieses Tutorial hat eine Implementierung der schnellen Sortierung in der Java -Computersprache erläutert.