✅ Einfache JavaScript-Sortieralgorithmen

Inhaltsverzeichnis

Ein Algorithmus ist per Definition eine geordnete Menge (Dies ist sehr wichtig) systematischer Operationen, die es uns ermöglichen, eine Berechnung durchzuführen, um die Lösung aller Probleme des gleichen Typs zu finden. Mit anderen Worten, es handelt sich um eine Reihe von Anweisungen, die immer dem folgenden Muster folgen:

Präzision: Sie müssen jeden Schritt oder jede Anweisung eindeutig und eindeutig erklären.
Endlich: Die Anzahl der auszuführenden Anweisungen muss begrenzt werden.
Definition: Dieselben Eingangsdaten müssen immer dieselben Ausgangsinformationen liefern.
Eingang: Die Anzahl der Eingabeelemente kann null oder mehr betragen.
Auflösung: Es sollte immer ein Ergebnis erzeugen, das die Ausgabedaten (s) sind.

Wenn ein Algorithmus in einer bestimmten Programmiersprache implementiert wird, wird er zu einem Programm, das auf einem Computer ausgeführt werden kann, daher können wir sagen, dass ein Programm ein Algorithmus oder eine Reihe von Algorithmen ist, die in einer bestimmten Sprache geschrieben sind, die der Computer interpretieren kann. In diesem Fall wird dieses Programm als Rechenalgorithmus bezeichnet. Auf der anderen Seite, wenn kein Computer zum Laufen benötigt wird, sprechen wir von nicht-rechnerischen Algorithmen.

In unserem Fall werden wir darüber sprechen Rechenalgorithmen.

Da wir wissen, was ein Algorithmus ist, werden wir uns auf die Sortieralgorithmen konzentrieren, oder was gleich ist, den Algorithmus, der dazu dient, eine Liste zu sortieren und zurückzugeben, die ursprünglich mit zufällig platzierten, bereits geordneten Elementen versehen wurde.
Das 3 Sortieralgorithmen am bekanntesten sind Blase sortieren oder nach Blase sortieren, Auswahl sortieren oder nach Auswahl sortieren und Einfügen sortieren oder nach Einfügen sortieren. Alle von ihnen gelten als einfache Algorithmen oder Verfahren, da sie durch Iteration oder Wiederholung bis zu einer Anzahl n-mal gelöst werden.

1. Blase sortieren oder nach Blase sortierenNehmen wir als Beispiel ein Array mit vier Werten, in diesem Fall der Einfachheit halber vier Zahlen. Wir werden sehen, wie der Algorithmus funktioniert.

Reihe = (4, 7, 8, 5, 9);

Wir möchten, dass Sie es zum Beispiel vom höchsten zum niedrigsten geordnet zurückgeben, d. h. (9, 8, 7, 5, 4).

Dazu müssen wir als erstes die ersten beiden Werte fragen, welcher der größte ist. Für den Fall, dass der zweite Wert größer ist als der erste, wie es der Fall ist, sollten sie ausgetauscht werden, wenn sie dagegen bereits bestellt sind, lassen wir sie so, wie sie sind.
Dann müsste der gleiche Vorgang mit dem zweiten und dritten Wert wiederholt werden. In diesem Fall ist der dritte Wert größer, also würden wir ihn austauschen und unser Array = (7, 8, 4, 5, 9) belassen.
Dann wiederholen wir den vorherigen Schritt mit dem dritten und vierten Wert und tauschen sie wieder aus. (7, 8, 5, 4, 9).
Und schließlich nach der ersten Iteration wäre es: (7, 8, 5, 9, 4).
Es ist immer noch nicht geordnet, aber es wurde erreicht, dass das letzte Element, das rechte vom Ganzen, die 4 ist, wenn es als die kleinste Zahl von allen geordnet ist.
In der nächsten Runde, um unser Array zu ordnen, ist es nicht mehr notwendig, das letzte zu berücksichtigen, da wir bereits wissen, dass es geordnet ist, also würden wir das erste und zweite Element vergleichen, dann das zweite und dritte Element und schließlich das drittes und viertes Element und das Array würde bleiben: ( 8, 7, 9, 5, 4).
Nun werden das letzte und vorletzte Element sortiert.
Wir machen eine weitere Runde und vergleichen den ersten und zweiten Wert und dann den zweiten und dritten und das Array sieht so aus: (8, 9, 7, 5, 4).
Die letzten drei Elemente sind bereits geordnet, sodass es nur noch eine Umdrehung dauert, um das Array vollständig geordnet zu verlassen: (9, 8, 7, 5, 4).

So geht's Burburja-Algorithmus, die so genannt wird, weil in jeder Runde das letzte Element wie eine Blase aufsteigt und geordnet wird.

Jetzt implementiert zu JavaScript Es ist sehr einfach:

Funktionsblase (myArray) {var tam = myArray.length; for (var temp = 1; temp <size; temp ++) {for (var left = 0; left <(size - temp); left ++) {var right = left + 1; if (myArray [links] <myArray [rechts] {sortieren (myArray, left, right);}}} return myArray;}

Wir übergeben ein Array an unsere Funktion und berechnen darin als erstes seine Größe, berechnen die Anzahl der Elemente im Array.
Dann erstellen wir eine äußere Schleife, die unser Array so oft durchläuft, wie Elemente minus Eins haben (da es die Zeiten sind, die für eine vollständige Bestellung erforderlich sind).
Intern erstellen wir eine weitere Schleife, die die Werte durchläuft und jeden mit dem nächsten vergleicht, und wenn der linke kleiner als der rechte ist, tauscht er sie mit der Sortierfunktion aus, die wir als nächstes sehen werden.
Schließlich gibt es das geordnete Array zurück.

Funktion sort (myArray, value1, value2) {var temp = myArray [value1]; meinArray [Wert1] = meinArray [Wert2]; myArray [Wert2] = temp; meinArray zurückgeben;}

Dabei ist value1 der Index des ersten auszutauschenden Elements und value2 der Index des zweiten auszutauschenden Elements.

2. Auswahl sortierenDer Algorithmus, den wir unten sehen werden, verschiebt die Elemente nicht einzeln wie in der Blase, sondern durchläuft zuerst das gesamte Array und wählt dann das richtige Element zur Platzierung gemäß den Kriterien aus, die wir befolgen (z auf die niedrigste) und platziert es direkt an seiner Position, und so erhält der Algorithmus seinen Namen, indem er ein Element auswählt, nimmt und es mit einer einzigen Bewegung an seine richtige Position bewegt.

Im gleichen Beispiel wie zuvor Array = (4, 7, 8, 5, 9) wenn wir es zum Beispiel vom höchsten zum niedrigsten ordnen wollen, würden wir zuerst 9 auswählen und an erster Stelle platzieren und 4 würde den letzten belegen Position (9, 7, 8, 5, 4). In der zweiten Runde wählte er die 8 und tauschte sie mit der 7 aus, um in der richtigen Position zu bleiben. In den folgenden Runden würde ich nichts ändern, da es bereits bestellt wurde.

Der Code dieses Algorithmus wäre wie folgt:

Funktionsauswahl (myArray) {var tam = myArray.length; für (var temp = 0; temp <Größe -1; temp ++) {major = temp; for (var check = temp + 1; check <size; check ++) {if (myArray [check] <myArray [major] {major = check;}} sort (myArray, major, check);} return myArray;}

Der Code funktioniert ähnlich wie der der Blase, aber die äußere for-Schleife durchläuft die Werte von 0 bis N-2 (sie sind die gleiche Anzahl von Schritten zwischen 1 und N-1 wie in der Blase, aber die Operation ist anders ) direkt auf die Elemente wirken, um sie bei jeder Kurve in die richtige Position zu bringen.
Die Anzahl der Umdrehungen, die für alle zu ordnenden Elemente erforderlich sind, ist die gleiche wie in der N-1-Blase, da wir nach jeder Iteration ein Element an seiner Stelle belassen und dasjenige, das wir in den folgenden Umdrehungen ignorieren können.

Wir modifizieren die Sortierfunktion jedoch leicht, um uns die Schritte zu sparen, wenn wir feststellen, dass ein Element bereits geordnet ist:

Funktion sortieren (myArray, value1, value2) {if (value1 == value2) {return myArray; } var temp = myArray [Wert1]; meinArray [Wert1] = meinArray [Wert2]; myArray [Wert2] = temp; meinArray zurückgeben;}

Um dies zu erreichen, haben wir eine if-Schleife eingefügt, in der überprüft wird, ob die Werte übereinstimmen, dh ob sie bereits geordnet sind.

3. EinfügungssortierungSchließlich werden wir den effizientesten der drei Algorithmen sehen, da wir nicht immer N-1 Iterationen benötigen, um unser Array zu platzieren, wie wir unten sehen werden.

Dieser Einfügealgorithmus funktioniert ähnlich wie das Platzieren einer Kartenhand in einem Pokerspiel, während die Karten ausgeteilt werden.
Normalerweise ordnen wir die Karten nach Farben und darin in aufsteigender Reihenfolge wie folgt:
Zuerst wird eine Karte ausgeteilt, ein einzelnes Element, das geordnet wird (um einzigartig zu sein). Wenn es dann „j“ Elemente gibt, die vom kleinsten zum größten geordnet sind, nehmen wir das Element j + 1 und vergleichen es mit allen bereits geordneten Elementen. Wenn es einen kleineren findet, da die größeren nach rechts verschoben sind, wird dieses Element (j + 1) eingefügt und zum Rest verschoben.

Das Algorithmus einfügen übersetzt in JavaScript-Sprache ist wie folgt:

Funktion insert (myArray) {var tam = myArray.length, temp, place; for (var obj = 0; obj = 0 && myArray [place]> temp; place--) {myArray [place + 1] = myArray [place]; } myArray [Platz + 1] = temp; } meinArray zurückgeben;}