Schnelle Sortierung in JavaScript

Der QuickSort-Algorithmus unterteilt die Liste in Unterlisten und kombiniert diese Unterlisten, um eine sortierte Liste zu erreichen. Es nutzt den Ansatz der Kluft und Eroberung, um die Elemente des Arrays zu sortieren. Es gibt zahlreiche Algorithmen zum Sortieren einer Liste.

Wie schnell Sortieralgorithmus funktioniert

Der QuickSort -Algorithmus wählt ein Element aus und betrachtet es als ein Drehelement. Jetzt ist das Pivot -Element reserviert.

Als nächstes werden wir die beiden Zeiger 'P' und 'Q' nehmen.

Der 'P' Zeiger bewegt sich von der linken Seite zur rechten Seite und hört erst auf.

Der zweite Zeiger 'Q' bewegt sich von der rechten Seite zur linken Seite und hört auf, zu suchen, wenn er ein Element weniger als oder gleich dem Pivot -Element findet.

'P' sortiert also die kleineren Elemente auf der linken Seite und 'Q' sortiert die größeren Elemente auf der rechten Seite.

Jetzt werden wir die Arbeit des Schnellsortalgorithmus mit Hilfe eines Beispiels verstehen:

Angenommen, wir haben eine Reihe von sechs Elementen und möchten es mit einem QuickSort -Algorithmus in aufsteigender Reihenfolge sortieren:

Im ersten Schritt wählen wir '36' als Pivot -Element (Mid -Element):

Im nächsten Schritt wählen wir unsere Zeiger "P" Zeiger aus, um von links nach rechts und "Q" -Zeiger zu bewegen, um sich von der rechten Seite zur linken Seite zu bewegen:

Jetzt wird der Wert des linken Zeigers 'p' mit dem Drehwert verglichen, da '35' weniger als '36' den Zeiger 'P' auf das benachbarte Element bewegt. Vergleichen Sie andererseits den Wert des rechten Zeigers 'Q' mit dem Pivot -Wert, '39' ist größer als '36', sodass der 'Q' Zeiger zum linken benachbarten Element wechselt:

Jetzt zeigt der 'P' Zeiger auf '33' und wird mit Pivot '36' verglichen, der Wert des Zeigers 'P' ist geringer als der Drehwert, daher wird Zeiger 'P' auf das angrenzende Element verlagert. Während der Wert des Zeigers '32' weniger als Pivot -Wert '36' ist, hört er hier auf:

Der Wert des linken Zeigers '37' ist größer als der Wert des Pivots '36', also wird er auch hier aufhören. Jetzt hält 'P' an '37' und 'q' haltet bei '32' an.

Jetzt werden wir überprüfen, ob der Zeiger "P" den Zeiger "Q" überschreitet oder nicht. In diesem Fall kreuzt 'P' P. bisher nicht den Zeiger 'q', daher werden wir den Wert des Zeigers 'P mit dem Wert des Zeigers' Q 'tauschen:

Jetzt zeigen 'P' und 'Q' auf '32' bzw. '37', verschieben die Zeiger noch einmal, jetzt p = q ('36 '=' 36 '):

Bewegen. Bis jetzt befindet sich das Pivot -Element in seiner rechten Position und alle Elemente, die größer als das Drehelement sind. Auf diese Weise werden wir die gesamte Liste sortieren.

Jetzt werden wir dieses Konzept in JavaScript implementieren. Erstens der Code zum Tauschelemente:

Funktion Swap_elements (Elemente, links_index, right_index)
var temp = elements [links_index];
Elemente [links_index] = Elemente [right_index];
Elemente [right_index] = temp;

Als nächstes unterteilt der Code, um eine Liste in Unterlisten zu unterteilen:

Funktion sub_lists (Elemente, Left_pointer, right_pointer)
var pivot = Elemente [Mathematik.Boden ((rechts_pointer + links_pointer) / 2)]],
i = links_pointer,
j = right_pointer;
während ich <= j)
während (Elemente [i] pivot)
J--;

if (i 1)
index = sub_lists (Elemente, links_pointer, right_pointer);
if (links_pointer < index - 1)
Quick_Sort (Elemente, Left_pointer, Index - 1);

if (index < right_pointer)
Quick_Sort (Elemente, Index, right_pointer);


Returnelemente;

Wir haben eine Funktion erstellt, die drei Parameter innerhalb der Funktion aufnimmt. Wir teilen die gesamte Liste in Unterlisten auf und finden den linken Zeiger und den rechten Zeiger heraus und schreiben den Code, um den linken Zeiger zu erhöhen, wenn er geringer ist als das Drehelementelement und den rechten Zeiger, wenn er größer ist als das Pivot-Element:

Jetzt schreiben wir den Code, um das rekursive Verhalten der schnellen Sortierung zu behandeln. Da im obigen Schritt Left_Pointers Index zurückgegeben wird und wir sie verwenden, um die Liste in Unterlisten zu unterteilen und Quicksort auf diese Unterlisten anzuwenden:

Funktion Quick_Sort (Elemente, Left_pointer, right_pointer)
var Index;
if (Elemente.Länge> 1)
index = sub_lists (Elemente, links_pointer, right_pointer);
if (links_pointer < index - 1)
Quick_Sort (Elemente, Left_pointer, Index - 1);

if (index < right_pointer)
Quick_Sort (Elemente, Index, right_pointer);


Returnelemente;

Der komplette Code -Snippet wird so verlaufen:

VAR -Elemente = [35,33,37,36,32,39];
Funktion Swap_elements (Elemente, links_index, right_index)
var temp = elements [links_index];
Elemente [links_index] = Elemente [right_index];
Elemente [right_index] = temp;

Funktion sub_lists (Elemente, Left_pointer, right_pointer)
var pivot = Elemente [Mathematik.Boden ((rechts_pointer + links_pointer) / 2)]],
i = links_pointer,
j = right_pointer;
während ich <= j)
während (Elemente [i] pivot)
J--;

if (i 1)
index = sub_lists (Elemente, links_pointer, right_pointer);
if (links_pointer < index - 1)
Quick_Sort (Elemente, Left_pointer, Index - 1);

if (index < right_pointer)
Quick_Sort (Elemente, Index, right_pointer);


Returnelemente;

var Sorted_array = Quick_Sort (Elemente, 0, Elemente.Länge - 1);
Konsole.log ("Die sortierte Liste:", sorted_array);

Wir haben das unsortierte Array zu Beginn des Programms initialisiert und am Ende des Programms die Funktion "Quick_Sort ()" bezeichnet, um das endgültige Sortierarray zu erhalten:

Wenn wir diesen Code ausführen, erhalten wir schließlich die resultierende Ausgabe als:

Abschluss:

Quicksort ist ein Sortieralgorithmus, der an der Kluft und der Eroberung der Philosophie arbeitet und das Problem in kleinere Unterprobleme unterteilt. Und setzen Sie diesen Prozess fort, bis Sie das resultierende Ziel erreichen. In diesem Artikel diskutieren wir, wie Quicksort funktioniert, und implementieren dieses Konzept in JavaScript, um jedes Array auf die effizienteste Weise zu sortieren.