Prioritätswarteschlange in Java

Angenommen, Sie bieten drei verschiedenen Personen, die vor Ihnen stehen, Service anbieten. Die dritte Person ist zufällig dein Freund. Der Dienst soll zuerst geeignet sein. Mit der ersten Person hat die erste Person die größte Priorität. Die zweite Person hat die größere Priorität; die dritte Person, die geringere Priorität und so weiter. Sie werden nicht bestraft, wenn Sie die Erst-Come_First-Servication nicht beobachten. Sie haben beschlossen, zuerst Ihrem Freund zu dienen, dann der ersten Person, gefolgt von der zweiten Person. Dies bedeutet, dass Sie Ihrem Freund die größte Priorität gegeben haben. Wenn man das Szenario aus Sicht eines Roboters betrachtete, hatte die dritte Position die größte Priorität.

Am nächsten Tag kamen die gleichen drei Leute. Diesmal ist dein Freund in der Mitte. Sie haben beschlossen, ihm zuerst zu dienen, vor der Person, die zuerst kam, dann der dritten Person und schließlich der ersten Person. Diesmal hat Position 2 diesmal laut Roboter die größte Priorität, gefolgt von Position 3.

Am dritten Tag ist dein Freund der erste und du machst das erste Come_First-Service. Die Schlussfolgerung durch jeden und der Roboter ist, dass die Priorität davon abhängt, wer besorgt ist, und von der Position jeder Person. Hinweis: Im wirklichen Leben hängt die Priorität nicht immer von der Erst-Come_First-Service ab.

In der Programmierung hat eine Binärprioritätswarteschlange, wo der erste Artikel die größte Priorität hat. Der dritte Artikel kann die größere Priorität und den zweiten Punkt, die dritte Priorität haben. Prioritätswarteschlangen sind binärer Natur. Hinweis: Der erste Artikel hat immer die größte Priorität in einer Prioritätswarteschlange. Es kann auch passieren, dass der zweite Punkt die größere Priorität hat und der dritte Punkt die dritte Priorität hat. In der Definition der Prioritätswarteschlange sind die Prioritäten der zweiten und dritten Elemente möglicherweise nicht in absteigender Reihenfolge vorhanden. Dieser Unterschied setzt die Warteschlange bis zum letzten Artikel fort. Es wird jedoch zu denen der niedrigsten Priorität gehören. Dieser Teilsort ist auch als Teilbestellung bekannt. Eine Prioritätswarteschlange ist also eine Warteschlange der teilweisen Bestellung, in der Priorität nicht erster Come_First-Service ist, obwohl dies die allgemeine Regel ist.

Beim Umgang mit dem Array ist First-Come_First-Service First-in_First-Out, geschrieben als FIFO. In der Computing ist die Warteschlange FIFO, während die vorrangige Warteschlange ein teilweise FIFO ist. Wenn die vorrangige Warteschlange weiter abfährt, steigt der Abstand zwischen solchen nahen Vorgängern und den höheren Prioritäten.

Eine vorrangige Warteschlange wird als Heap -Datenstruktur implementiert. Die nächste Frage ist, was ist ein Haufen? Es gibt den maximalen Haufen und den minimalen Haufen, der im Folgenden ausführlich erörtert wird.

Artikelinhalt

• Haufen Datenstruktur
• Prioritätswarteschlange in Java eigentlich
• Java -Konstruktion einer vorrangigen Warteschlange
• Java -Methoden einer vorrangigen Warteschlange
• Abschluss

Haufen Datenstruktur

Es gibt Max-heap und es gibt Mine-heap. Mit max-heap ist der erste Artikel der größte Wert. Wenn die Warteschlange abstammt, verringern sich die Werte weiter, erhöhen und im Allgemeinen. Mit Min-heap ist der erste Artikel der kleinste Wert. Wenn die Warteschlange absteigt, steigen und sinken die Werte weiter und nehmen allgemein ab. Die Werte eines Haufens können in einem Array aufbewahrt werden.

In einem binären Haufen ist ein Knoten (Gegenstand) zwei Kinder. Das erste Kind ist das linke Kind und das zweite Kind ist das rechte Kind. Der Wert eines jeden Knotens wird als Schlüssel bezeichnet.

Max-heap

Die folgende Liste ist ein Max-HEAP, der bereits teilweise bestellt wurde und keine weitere Bestellung benötigt:

89, 85, 87, 84, 82, 79, 73, 80, 81,, 65, 69

89 ist der erste Wert bei Index 0. Es ist der Stammknoten (Root übergeordnet). Es ist der größte Wert unter allen Werten. Sein erstes Kind (85) befindet sich bei Index 1, dessen Index 2 (0) + 1 entspricht, wobei 0 der Index des übergeordneten ist. Sein zweites Kind (87) befindet sich in Index 2, was gleich 2 (0) + 2 entspricht, wobei 0 der Index des Elternteils ist.

85 befindet sich am Index 1. Es ist ein Elternteil. Sein erstes Kind (84) befindet sich in Index 3, was 2 (1) + 1 entspricht, wobei 1 der Index des übergeordneten ist. Sein zweites Kind (82) befindet sich in Index 4, was 2 (1) + 2 entspricht, wobei 1 der Index des Elternteils ist.

87 ist am Index 2. Es ist ein Elternteil. Sein erstes Kind (79) befindet sich in Index 5, was 2 (2) + 1 entspricht, wobei 2 der Index des Elternteils ist. Sein zweites Kind (73) befindet sich in Index 6, was 2 (2) + 2 entspricht, wobei 2 der Index des Elternteils ist.

Im Allgemeinen, wenn die Indexzählung von 0 beginnt, sollte ich den Index eines Elternteils des Arrays darstellen. und so ist das linke (erste) Kind eines Elternteils bei Index I bei Index 2i + 1; und sein rechtes (zweites) Kind ist bei Index 2i + 2. Einige Zellen gegen Ende des Arrays können leer sein; Sie dürfen keine Werte haben.

Die vorherige Liste ist ein gutes Beispiel für den Inhalt einer Prioritätswarteschlange, nachdem die Aufnahme von Elementen abgeschlossen ist. Wenn das erste Element entfernt wird, wird der Rest neu angeordnet, um die Werte eingerichtet zu haben, wodurch eine neue Prioritätswarteschlange erfolgt. Auf diese Weise würde das Entfernen aller Elemente von oben so aussehen, als würden alle Elemente richtig sortiert wären. Die Elemente können immer noch so erhalten werden, wie sie in einer teilweisen Reihenfolge sind, ohne ein Element zu entfernen.

Min-heap

Min-heap ist die Rückseite von Max-heap.

Prioritätswarteschlange in Java eigentlich

Java hat eine Klasse namens Priorityqueue für Prioritätsqueue. Es hat viele Konstruktoren und Methoden. Nur drei Konstruktoren und die geeigneteren Methoden werden nachstehend erläutert:

Java -Konstruktion einer vorrangigen Warteschlange

Öffentliche Priorität ()

Dies schafft eine vorrangige Warteschlange ohne Element. Die Klasse Priorityqueue befindet sich in der Java.Util.* Paket, das importiert werden muss. Das folgende Codesegment erstellt eine leere Priorität und fügt dann der Warteschlange unortheilte (nicht einmal teilweise sortierte) Werte hinzu:

Prioritätswarteschlange PQ = neue Prioritätsqueue();
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85);

Diese Zahlen sind alle Ganzzahlen. Sie stammen aus der oben angegebenen teilweise sortierten Liste. Die Elemente in PQ werden jetzt teilweise nach der Definition der Prioritätswarteschlange in Java sortiert.

Öffentliche Priorität (Priorität C)

Dies schafft eine Priorität aus einer anderen Priorität. Das folgende Codesegment zeigt dies:

Prioritätswarteschlange PQ = neue Prioritätsqueue();
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85);
Prioritätswarteschlange pq1 = neuer Prioritätsqueue(PQ);

PQ1 wurde aus PQ erstellt. Es hat derzeit die gleiche Teilreihenfolge und PQ.

Die dritte Konstruktormethode ist unten dargestellt.

Java -Methoden einer vorrangigen Warteschlange

Öffentliche int size ()

Dies gibt die Größe der Liste zurück und enthält keine leeren Zellen, wie im folgenden Code dargestellt:

Prioritätswarteschlange PQ = neue Prioritätsqueue();
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85);
int sz = pq.Größe();
System.aus.println (SZ);

Die Ausgabe ist 11.

Öffentliche Leere für den Verbraucher (Verbraucheraktionen)

Diese Methode muss auf besondere Weise verwendet werden. Das folgende Programm zeigt dies:

Prioritätswarteschlange PQ = neue Prioritätsqueue();
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85);
pq.foreach (Element -> System.aus.print (item + ""));
System.aus.println ();

Beachten Sie die Art und Weise, wie der Code in den Klammern der Foreach -Methode erstellt wurde. Das Element ist eine Dummy -Variable, die jedes Element in der Warteschlange darstellt. Beachten Sie die Verwendung des Pfeilbetreibers. Die Ausgabe ist:

65 69 84 79 73 87 89 80 81 82 85

Die Ausgabe ist in teilweise Reihenfolge korrekt, jedoch in einer aufsteigenden Reihenfolge. Dies ist nicht unbedingt die oben angegebene umgekehrte Reihenfolge, da die Werte in der Liste enthalten waren. Das heißt. Verwenden Sie den folgenden Konstruktor, um die Liste in absteigender Reihenfolge zurückzugeben:

Öffentliche Priorität (Komparatorvergleich)

Dies ist ein Konstruktor. Der folgende Code zeigt, wie es verwendet wird:

Prioritätswarteschlange PQ = neue Prioritätsqueue((x, y) -> Ganzzahl.vergleiche (y, x));
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85);
pq.foreach (Element -> System.aus.print (item + ""));

Das x, y sind Dummy -Variablen, die die geringeren und die weniger Werte darstellen. Beachten Sie, dass X in den ersten Klammern für x und y vor y kommt. In den zweiten Klammern kommt y vor x. Die Ausgabe ist:

89 85 87 80 82 69 84 65 79 73 81

Öffentlicher Boolescher Add (e e)

Die Anzahl der Elemente in einer vorrangigen Warteschlange kann nacheinander erhöht werden. Diese Methode kehrt wahr, wenn eine Änderung stattgefunden hat. und sonst falsch. Der folgende Code fügt der Warteschlange den zwölften praktischen Wert hinzu:

Prioritätswarteschlange PQ = neue Prioritätsqueue((x, y) -> Ganzzahl.vergleiche (y, x));
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85); pq.hinzufügen (70);
pq.foreach (Element -> System.aus.print (item + ""));

Der Mehrwert würde die Warteschlange nach oben bewegen, um sich an seine angemessene Position anzupassen, was zu einer erneuten Anpassung der Elementpositionen führt. Die Ausgabe ist:

89 85 87 80 82 70 84 65 79 73 81 69

Öffentliche E -Umfrage ()

Diese Methode holt und entfernt den Kopf der Warteschlange; oder kehrt null zurück, wenn diese Warteschlange leer ist. Jedes Mal, wenn der Kopf entfernt wird. Wenn der Kopf weiterhin entfernt wird, werden die zurückgegebenen Werte in vollständiger Reihenfolge sein. Der folgende Code zeigt dies:

Prioritätswarteschlange PQ = neue Prioritätsqueue((x, y) -> Ganzzahl.vergleiche (y, x));
pq.hinzufügen (69); pq.hinzufügen (65); pq.add (87); pq.hinzufügen (79);
pq.hinzufügen (73); pq.add (84); pq.add (89); pq.hinzufügen (80);
pq.add (81); pq.add (82); pq.add (85); pq.hinzufügen (70);
pq.foreach (Element -> System.aus.drucken (pq.POLL () + ""));

Die Ausgabe vom Computer des Autors lautet:

89 87 85 84 82 81 80 79 73 70 69 65 Ausnahme in Thread "Main" Java.Util.ConcurrentModificationException
bei Java.Basis/Java.Util.Prioritätswarteschlange.foreach (Priorität.Java: 984)
In der Klasse.Haupt (TheClass.Java: 11)

Beachten Sie, dass die Ausgabe vollständig sortierter Reihenfolge ist. Dieser spezielle Code konnte die eingegangene Ausnahme nicht aufnehmen. Dieses Problem bleibt als Forschungsübung für den Leser.

Abschluss

Eine vorrangige Warteschlange in Java ist eine Warteschlange, in der Elemente andere Priorität als FIFO haben. Eine vorrangige Warteschlange ist in der Regel ein Haufen. Die Werte müssen vom gleichen Typ sein. Sie werden in der Warteschlange im Heap -Format gespeichert (teilweise Bestellung). Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Schauen Sie sich die anderen Linux -Hinweisartikel für Tipps und Tutorials an.