Prioritätswarteschlangen in JavaScript

Eine Prioritätswarteschlange ist eine Erweiterung einer einfachen Warteschlangedatenstruktur mit Elementen, die einen Prioritätswert enthalten. Eine Warteschlange ist eine Sammlung von Elementen, in denen das erste Element zur Eingabe der Warteschlange das erste Element ist, das aus einer Warteschlange herauskommt. Diese Ausführungstechnik ist als die bekannt FIFO (zuerst in und zuerst). Betrachten Sie eine Reihe von Personen, die außerhalb eines Geldautomaten stehen. Die Person, die zuerst in der Linie steht, ist derjenige, der zuerst den Geldautomaten benutzt. Die Person, die spät in der Warteschlange für den Geldautomaten einnimmt, wird der letzte sein, der den Geldautomaten benutzt.

Jetzt wissen wir also, was eine grundlegende Warteschlange ist, aber was ist mit der Prioritätswarteschlange? In der Prioritätswarteschlange hat jedes Element, das in die Warteschlange eingeht, zwei Werte, einen Prioritätswert und die Daten. Die Elemente mit dem gleichen Prioritätswert werden basierend auf FIFO (zuerst in und zuerst) Aber Elemente mit höherer Priorität als andere werden zuerst ausgeführt, egal wann sie in die Warteschlange hinzugefügt wurden.

Dies ist ein Thema für erweiterte Datenstruktur. Daher gehen wir davon aus, dass Sie mit der Funktionsweise von JavaScript und den grundlegenden Funktionen von JavaScript vertraut sind. Um eine vorrangige Warteschlange in JavaScript zu implementieren, müssen wir zunächst wissen, wie eine einfache Warteschlange in JavaScript implementiert werden kann.

Implementierung einer Warteschlange in JavaScript

Die Datenstrukturkonzepte wie Warteschlangen, Stapel, Haufen oder vorrangige Warteschlangen werden mit Arrays in JavaScript implementiert.

Lassen Sie uns eine Funktion definieren, die unsere Struktur definiert:

Funktion queue ()
// später wird der Code hier platziert

Wir wissen, dass Warteschlangen mit Arrays implementiert sind, daher werden wir ein Array mit dem Namen Kollektionen erstellen

Innerhalb der Funktion:

Array = [];

Um die Queues -Datenstruktur zu implementieren, müssen wir nun die folgenden Funktionen implementieren:

• Enqueue: Fügen Sie am Ende der Liste ein neues Element hinzu
• DEQUEUE: Um das erste Element aus der Liste zu entfernen
• Isempty: Überprüfen Sie, ob die Warteschlange leer ist oder nicht
• Größe: Um die Länge der Warteschlange zurückzugeben
• Front: Um den Wert des ersten Elements in der Liste zurückzugeben
• Drucken: Um die Warteschlange zu drucken

Diese Funktionen können alle leicht hinzugefügt werden, indem die folgenden Codezeilen verwendet werden:

functionQueue ()
Array = [];
Das.print = function ()
Konsole.log (Array);
;
Das.enqueue = function (newmem)
Array.Push (NewMem);
;
Das.dequeue = function ()
ReturnArray.Schicht();
;
Das.vorne = function ()
Return Array [0];
;
Das.size = function ()
ReturnArray.Länge;
;
Das.isEmpty = function ()
Rückkehr (Array.Länge === 0);
;

Nachdem wir unsere Datenstruktur bereit haben, müssen wir ein Objekt erstellen, das dieser Struktur zugeordnet ist. Wir tun dies mit der Zeile:

var newQueue = new Queue ();

Jetzt brauchen wir einige Elemente, die in die Warteschlange platziert werden sollen. Wir tun dies mit den folgenden Zeilen:

Newqueue.Enqueue ('a');
Newqueue.Enqueue ('B');
Newqueue.Enqueue ('C');

Um zu sehen, wie unsere Warteschlange gerade aussieht, können wir die Druckfunktion wie SO aufrufen:

Newqueue.drucken();

Wir erhalten die folgende Ausgabe auf unserer Konsole:

Um zu testen, werden wir ein Element aus der Liste aus der Liste entfernen, wenn die erste In-In-Implementierung korrekt funktioniert, und den wichtigsten Wert drucken und dann die gesamte verbleibende Warteschlange mit den folgenden Zeilen ausdrucken:

Newqueue.dequeue ();
Konsole.Protokoll (NewQueue.Vorderseite());
Newqueue.drucken();

Der vollständige Code -Ausschnitt der Warteschlangenstruktur lautet:

functionQueue ()
Array = [];
Das.print = function ()
Konsole.log (Array);
;
Das.enqueue = function (newmem)
Array.Push (NewMem);
;
Das.dequeue = function ()
ReturnArray.Schicht();
;
Das.vorne = function ()
Return Array [0];
;
Das.size = function ()
ReturnArray.Länge;
;
Das.isEmpty = function ()
ReturnArray.Länge === 0;
;

varNewQueue = new Queue ();
Newqueue.Enqueue ("a");
Newqueue.Enqueue ("B");
Newqueue.Enqueue ("C");
Newqueue.drucken();
Newqueue.dequeue ();
Konsole.Protokoll (NewQueue.Vorderseite());
Newqueue.drucken();

Bei der Ausführung dieses Code können wir das folgende Ergebnis auf der Konsole beobachten:

Als wir also die Dequeue -Funktion anrufen, entfernte es das erste Element aus der Liste. Danach haben wir nach dem wichtigsten Element in der Warteschlange nachge eingereicht, das war "B". Dann druckten wir die Warteschlange erneut und sie gab uns die verbleibende Warteschlange in der richtigen Reihenfolge. Dies bedeutet, dass unsere Warteschlangenimplementierung perfekt funktioniert:

Implementierung einer vorrangigen Warteschlange in JavaScript

Wir kennen den Unterschied zwischen einer normalen Warteschlange und einer Prioritätswarteschlange, dass die Elemente in der Prioritätswarteschlange zusammen mit ihren Daten einen Prioritätswert enthalten. Dies bedeutet, dass die gesamte Funktionalität der Prioritätswarteschlange mit Ausnahme der normalen Warteschlange überein ist Enqueue -Funktion.

In der Prioritätswarteschlangen stellt die Enqueue -Funktion das Element mit höherer Priorität vor dem Element mit niedrigerer Priorität. Und wenn zwei oder mehr Elemente die gleiche Priorität haben.

Beachten Sie also, dass wir die neue Enqueue -Funktion für die Prioritätswarteschlange mit den folgenden Codezeilen schreiben können:

Das.enqueue = function (newmem)
var array = [];
// später wird der Code hier platziert
;

Das erste, was wir in der Enqueue -Funktion machen, ist, dass wir das Element einfach in die Warteschlange drücken, wenn die Sammlung leer ist:

if (das.ist leer())
Array.Push (NewMem);

Wenn die Warteschlange nicht leer ist:

• Dann werden wir die Priorität des neuen Elements mit der Priorität jedes Elements in der Warteschlange überprüfen
• Wenn die Priorität des neuen Elements niedriger ist als das Element der Sammlung.Wir werden das neue Element vor dem Element dieser Sammlung hinzufügen
• Das ist weil 1 bedeutet erste Priorität wohingegen 2 bedeutet zweite Priorität
• Wenn die Priorität des neuen Elements höherer Wert (niedrigerer Priorität niedriger), werden wir uns bis zum Ende der Warteschlange bewegen und dort das Element hinzufügen

anders
var addiert = false;
für (vari = 0; iif (newmem [1] < array[i][1])
Array.Splice (i, 0, Newmem);
hinzugefügt = wahr;
brechen;


Wenn (!hinzugefügt)
Array.Push (NewMem);

Das Ganze Enqueue Die Funktion sieht so aus:

Das.enqueue = function (newmem)
if (das.ist leer())
Array.Push (NewMem);
anders
var addiert = false;
für (vari = 0; iif (newmem [1] < array[i][1])
Array.Splice (i, 0, Newmem);
hinzugefügt = wahr;
brechen;


Wenn (!hinzugefügt)
Array.Push (NewMem);


;

Der Rest der Prioritätswarteschlangenfunktionen sind ziemlich übereinstimmend wie die normal. Der gesamte Prioritäts -Warteschlangencode -Snippet lautet wie:

functionPriorityQueue ()
varArray = [];
Das.printCollection = function ()
Konsole.log (Array);
;
Das.enqueue = function (newmem)
if (das.ist leer())
Array.Push (NewMem);
anders
var addiert = false;
für (vari = 0; iif (newmem [1] Array.Splice (i, 0, Newmem);
hinzugefügt = wahr;
brechen;


Wenn (!hinzugefügt)
Array.Push (NewMem);


;
Das.dequeue = function ()
var value = Array.Schicht();
Rückgabewert [0];
;
Das.vorne = function ()
returnArray [0];
;
Das.size = function ()
ReturnArray.Länge;
;
Das.isEmpty = function ()
ReturnArray.Länge === 0;
;

Zeit, Elemente in die Warteschlange mit den folgenden Codezeilen zu setzen:

var pq = new PriorityQueue ();
pq.enqueue (["Google", 2]);
pq.Enqueue (["Bing", 3]);
pq.Enqueue (["Microsoft", 1]);
pq.Enqueue (["Apple", 2]);
pq.printCollection ();

Wie Sie sehen können, ist die erste Priorität die "Microsoft" Element mit Wert 1. Es muss zu Beginn der Warteschlange sein, auch wenn es auf dem 3. Platz hinzugefügt wurde.

Wenn wir nun die Dequeue -Funktion aufrufen und die Druckfunktion erneut das erste Element aus der Liste entfernt werden sollte:

pq.dequeue ();
pq.printCollection ();

Da Sie gehen, funktioniert unsere Prioritätswarteschlange perfekt.

Abschluss

Warteschlangen sind Datenstrukturkonzepte, die zur Bewertungsmethode von First-in und First-Out funktionieren. In ähnlicher Weise wirken die Prioritätswarteschlangen an der Bewertung von First-in und First-Out, aber mit einem zusätzlichen Wert von „Priorität“ wird das Element mit höchster Priorität zuerst ausgeführt, unabhängig davon, wann sie zur Warteschlange hinzugefügt wurden. In diesem Beitrag haben wir gelernt, wie man eine einfache Warteschlange in JavaScript implementiert und wie diese Datenstruktur verwendet wird, um die Arbeit einer Prioritätswarteschlange zu implementieren.