Binäre Haufen in JavaScript
Das Haufen Eigentum
Diese Eigenschaft kann als Einschränkung für die Definition eines Baumes angesehen werden, eine bestimmte Struktur, die beim Bau eines Baumes befolgt werden muss. Heap definiert eine Beziehung zwischen den übergeordneten Knoten und ihren untergeordneten Knoten, es gibt zwei Arten von Haufen, und daher gibt es zwei Arten von Beziehung, die zwischen dem übergeordneten Knoten und dem Kinderknoten bestehen können:
- Max-heap: Der Wert der übergeordneten Knoten muss immer größer oder gleich den Kinderknoten sein
- Min-heap: Der Wert der übergeordneten Knoten muss immer kleiner oder gleich den Kinderknoten sein
Eine Darstellung des Mine-HEAP ist:
(Bild von Wikipedia)
Wie Sie sehen können, haben in dem Baum, dass die übergeordneten Knoten niedrigere Werte haben als ihre Kinderknoten
AR-Darstellung des Max-heap ist:
(Bild von Wikipedia)
Sie können sehen, dass die übergeordneten Knoten größer sind als ihre Kinderknoten.
Array -Darstellung
Haufen in einer Programmiersprache sind in Form eines Arrays dargestellt. Ein Beispiel für das aus dem oben genannte Max-Hap-Baum stammende Haufen Array ist:
var max-heap = [100,19,36,17,3,25,1,2,7];Wenn Sie einen binären Haufen in Form eines Arrays darstellen, verwenden Sie den folgenden Ausdruck, um Folgendes abzuleiten:
- Linke Kind = i * 2
- Richtiges Kind = i * 2 + 1
- Eltern = I / 2
Wo "ich" steht für den Index des Arrays. Wenn wir über Indizes sprechen, setzen wir bei der Implementierung von Heap -Strukturen ein A -Array "Null" Im ersten Index, der der Index ist 0.
Visuelle Darstellung der Arbeit eines Haufens
Für eine virtuelle Darstellung der Arbeit eines Minimas und wie die Werte in den Haufen eingefügt werden, können wir uns zum Heap Visualizer der Universität von San Francisco wenden, indem wir hier klicken
Fügen Sie Werte in den Haufen ein und Sie werden feststellen, wie ein neues Element aufgrund der Animation in den Haufen eingefügt wird:
Arbeiten von Haufen
Ein binärer Haufen hat zwei Hauptfunktionen:
- Zunächst muss das neue Element an seiner geeigneten Position hinzugefügt werden
- Die zweite Funktion besteht darin, den Wurzelwert zu entfernen
Hinzufügen eines neuen Elements in den Haufen
Am Ende des Arrays wird immer ein neues Element hinzugefügt und dann gegen seinen Elternteil überprüft. Wenn es gegen das Heap -Eigentum verstößt, wird es mit seinem Elternteil ausgetauscht. Das Element wird überprüft, bis es mit dem Wurzelknoten des Heaps verglichen wurde (Wurzelknoten ist der erste Knoten des Haufens).
Entfernen eines Elements vom Haufen
Wenn Sie einen Wert aus dem Haufen entfernen oder abrufen möchten, holen Sie immer den Wert des Stammknotens ab. Deshalb ist dieser Wert der kleinste Wert, wenn es sich um ein Min-heap und der größte Wert handelt, wenn er ein maximaler Hauch ist. Wenn der Wurzelknoten vom Haufen entfernt wird, einnimmt der letzte Knoten des Arrays seinen Platz und wird mit seinen untergeordneten Knoten verglichen, um dem Zustand des Haufens zu entsprechen. Wenn es nicht mit der Bedingung übereinstimmt, wird es durch seinen Kinderknoten ersetzt und dann mit weiteren Kinderknoten überprüft. Ein viel besserer Weg, dies zu erklären, ist die Verwendung des Live -Heap -Viewers, wie unten gezeigt:
Sie können den Entfernungsprozess beobachten, indem Sie das GIF oben beobachten.
Implementierung des binären Haufens in JavaScript
Wir werden die min-heap Schritt für Schritt implementieren. Wir beginnen den Prozess, indem wir eine neue Funktion mit den folgenden Codezeilen erstellen:
lass minheap = function ()// Der Rest des Minim-Heap-Code wird vorhanden sein
Der erste Schritt besteht darin, ein Array zu erstellen und den Wert auf den Index festzulegen 0 als Null:
lass heap = [null];
Dann werden wir die erstellen Funktion einfügen Verwenden der folgenden Codezeilen:
Das.insert = function (num)
Haufen.Push (num);
if (haufen.Länge> 2)
letIdx = heap.Länge - 1;
while (heap [idx] = 1)
[Heap [Mathematik.Boden (idx / 2)], heap [idx]] = [
Heap [IDX],
Haufen [Mathematik.Boden (IDX / 2)],
];
if (Mathe.Boden (IDX / 2)> 1)
idx = math.Boden (IDX / 2);
anders
brechen;
;
In diesem Code -Snippet passieren die folgenden Dinge:
- Ein neues Element num wird im letzten Index des Arrays hinzugefügt
- Wenn die Arraylänge größer als 2 Elemente ist, überprüfen wir das neue Element mit seinem übergeordneten Knoten
- Wenn das Element kleiner als sein übergeordneter Knoten ist, wird es durch seinen übergeordneten Knoten ersetzt. Andernfalls schließen wir den Haufen in korrekter Reihenfolge aus
- Wenn das Element im vorherigen Schritt durch seinen übergeordneten Knoten ersetzt wird, vergleichen wir es erneut mit seinem neuen übergeordneten
Der nächste Schritt besteht darin, die implementieren Funktion entfernen Mit den folgenden Codezeilen:
Das.remove = function ()Sei kleinst = haufen [1];
if (haufen.Länge> 2)
Heap [1] = Heap [Heap.Länge - 1];
Haufen.Spleiß (Haufen.Länge - 1);
if (haufen.Länge == 3)
if (heap [1]> heap [2])
[Heap [1], Heap [2]] = [Heap [2], Heap [1]];
am kleinsten zurückkehren;
leti = 1;
letleft = 2 * i;
LETRYP = 2 * i + 1;
while (heap [i]> = heap [links] || heap [i]> = heap [rechts])
if (haufen [links] < heap[right])
[heap [i], heap [links]] = [heap [links], heap [i]];
i = 2 * i;
anders
[heap [i], heap [rechts]] = [heap [rechts], heap [i]];
i = 2 * i + 1;
links = 2 * i;
rechts = 2 * i + 1;
if (heap [links] == undefined || heap [rechts] == undefiniert)
brechen;
elseif (haufen.Länge == 2)
Haufen.Spleiß (1, 1);
anders
null zurückkehren;
am kleinsten zurückkehren;
;
Die folgenden Schritte finden im obigen Code -Snippet statt:
- Wir entfernen den Wurzelknoten, da er der kleinste Knoten des Haufens ist
- Wenn der Haufen nur zwei Elemente hat, wird das 2. Element zum Wurzelknoten
- Wenn der Haufen 3 Elemente hat, wird das kleinste aus dem 2. und 3. Element zum Wurzelknoten
- Wenn das Element mehr als 3 Elemente hat, wird das letzte Element des Haufens zum Wurzelknoten
- Dann wird dieser neue Wurzelknoten mit seinen untergeordneten Knoten verglichen und durch den kleineren Knoten ersetzt und ist gegen die neuen untergeordneten Knoten (für den Austausch verwenden wir die Destructuring -Methode von Objekt)
- Dieser Prozess des Vergleichs des Elements mit den untergeordneten Knoten wird wiederholt, bis es einen Punkt erreicht.
Der nächste Schritt besteht darin, eine Funktion zu erstellen, die uns das Heap -Array in die Konsole anzeigt. Wir tun dies mit den folgenden Codezeilen:
Das.show = function ()Konsole.log (haufen);
;
Der vollständige Code-Snippet zur Implementierung der min-heap-Datenstruktur lautet:
letMinheap = function ()lass heap = [null];
Das.insert = function (num)
Haufen.Push (num);
if (haufen.Länge> 2)
letIdx = heap.Länge - 1;
while (heap [idx] = 1)
[Heap [Mathematik.Boden (idx / 2)], heap [idx]] = [
Heap [IDX],
Haufen [Mathematik.Boden (IDX / 2)],
];
if (Mathe.Boden (IDX / 2)> 1)
idx = math.Boden (IDX / 2);
anders
brechen;
;
Das.remove = function ()
Sei kleinst = haufen [1];
if (haufen.Länge> 2)
Heap [1] = Heap [Heap.Länge - 1];
Haufen.Spleiß (Haufen.Länge - 1);
if (haufen.Länge == 3)
if (heap [1]> heap [2])
[Heap [1], Heap [2]] = [Heap [2], Heap [1]];
am kleinsten zurückkehren;
leti = 1;
links = 2 * i;
rechts = 2 * i + 1;
while (heap [i]> = heap [links] || heap [i]> = heap [rechts])
if (haufen [links] < heap[right])
[heap [i], heap [links]] = [heap [links], heap [i]];
i = 2 * i;
anders
[heap [i], heap [rechts]] = [heap [rechts], heap [i]];
i = 2 * i + 1;
links = 2 * i;
rechts = 2 * i + 1;
if (heap [links] == undefined || heap [rechts] == undefiniert)
brechen;
elseif (haufen.Länge == 2)
Haufen.Spleiß (1, 1);
anders
returnnull;
am kleinsten zurückkehren;
;
Das.show = function ()
Konsole.log (haufen);
;
;
Was wir jetzt tun müssen, besteht. Dazu machen wir eine neue Variable und zeichnen sie auf dem Mindeap mit den folgenden Codezeilen ab:
var newminhoap = neuer minheap ();Als nächstes fügen wir den Haufen mit den folgenden Codezeilen Werte hinzu:
Newminhoap.Insert (34);Newminhoap.Einfügen (61);
Newminhoap.Einfügen (138);
Newminhoap.Einfügen (82);
Newminhoap.Einfügen (27);
Newminhoap.Insert (35);
Jetzt nennen wir das zeigen Funktion zum Anzeigen des Heap -Arrays auf der Konsole:
Newminhoap.zeigen();Wir erhalten das folgende Ergebnis in unserer Konsole:
Wie Sie sehen können, ist das erste Element des Arrays Null. Der Rest der Knoten ist nicht größer als ihre Kinderknoten. Zum Beispiel, wenn wir den Knoten mit dem Wert nehmen 35. Das linke und das rechte Kind sind als:
Sie können deutlich sehen, die Elternteil (35) ist kleiner als das linke Kind (82) und sein rechtes Kind (61). In ähnlicher Weise ist jeder übergeordnete Knoten kleiner als sein Kinderknoten. Daher können wir schließen, dass unser Code perfekt funktioniert
In ähnlicher Weise können wir die Bedingung für den Vergleich, dass der übergeordnete Knoten kleiner als das Kind ist, wenn der übergeordnete Knoten größer ist als der untergeordnete Knoten, die wir die implementieren können Max-heap Verwenden der folgenden Codezeilen:
letMaxheap = function ()lass heap = [null];
Das.insert = function (num)
Haufen.Push (num);
if (haufen.Länge> 2)
letIdx = heap.Länge - 1;
while (heap [idx]> heap [mathematik.Boden (IDX / 2)])
if (idx> = 1)
[Heap [Mathematik.Boden (idx / 2)], heap [idx]] = [
Heap [IDX],
Haufen [Mathematik.Boden (IDX / 2)],
];
if (Mathe.Boden (IDX / 2)> 1)
idx = math.Boden (IDX / 2);
anders
brechen;
;
Das.remove = function ()
Sei kleinst = haufen [1];
if (haufen.Länge> 2)
Heap [1] = Heap [Heap.Länge - 1];
Haufen.Spleiß (Haufen.Länge - 1);
if (haufen.Länge == 3)
if (Heap [1] < heap[2])
[Heap [1], Heap [2]] = [Heap [2], Heap [1]];
am kleinsten zurückkehren;
leti = 1;
links = 2 * i;
rechts = 2 * i + 1;
während (Heap [i] <= heap[left] || heap[i] heap[right])
[heap [i], heap [links]] = [heap [links], heap [i]];
i = 2 * i;
anders
[heap [i], heap [rechts]] = [heap [rechts], heap [i]];
i = 2 * i + 1;
links = 2 * i;
rechts = 2 * i + 1;
if (heap [links] == undefined || heap [rechts] == undefiniert)
brechen;
elseif (haufen.Länge == 2)
Haufen.Spleiß (1, 1);
anders
returnnull;
am kleinsten zurückkehren;
;
Das.show = function ()
Konsole.log (haufen);
;
;
Das ist es, Sie haben erfolgreich eine binäre Haufen in JavaScript implementiert
Abschluss
Binäre Haufen sind die parietale Umsetzung eines binären Baums mit dem Zustand, das zu haben am meisten Zwei untergeordnete Knoten für jeden übergeordneten Knoten und die vollständige Struktur des binären Baums. Was bedeutet, dass die Ebenen des Baumes vom linken oder linken Kind und dann vom rechten Kind gefüllt werden.
Binäre Haufen sind Teil von fortschrittlichen Datenstrukturen, und es gibt zwei Arten von Binärbäumen: Einer davon wird als Min -Haufen bezeichnet, während der andere als maximaler Haufen bezeichnet wird. Im Mine-HEAP haben die übergeordneten Knoten kleinere Werte als ihre Kinderknoten, und die Werte der Geschwisterknoten spielt keine Rolle.
In ähnlicher Weise sind in Max-heap die Werte des übergeordneten Knoten. In diesem Beitrag haben wir von Haufen und ihrer Implementierung in Vanilla JavaScript erfahren und am Ende unsere Implementierung getestet.