java priority queue tutorial implementation examples
In diesem Lernprogramm werden die Java-Prioritätswarteschlange und verwandte Konzepte wie die Vergleichs-, Min- und Max-Prioritätswarteschlange sowie deren Implementierung anhand von Beispielen erläutert:
Die Datenstruktur der Prioritätswarteschlange ist eine spezielle Warteschlange, in der die Elemente nicht gemäß der FIFO-Reihenfolge vorhanden sind, sondern gemäß den natürlichen Elementen oder einem benutzerdefinierten Komparator, der während der Warteschlangenerstellung verwendet wird.
=> Schauen Sie sich hier den Java Beginners Guide an.
Was du lernen wirst:
Prioritätswarteschlange In Java
In der Prioritätswarteschlange weist die Vorderseite der Warteschlange die geringsten Elemente gemäß der natürlichen Reihenfolge auf, und die Rückseite zeigt auf das größte Element in der Warteschlange.
Ein Beispiel für eine Prioritätswarteschlange, die aus Zahlen besteht, ist unten dargestellt.
Wie spielt man SWF-Dateien ab?
Wenn also ein Element aus der oben gezeigten Prioritätswarteschlange entfernt wird, ist es das kleinste Element.
In ähnlicher Weise werden für eine alphabetische Prioritätswarteschlange ASCII-Werte berücksichtigt und die Warteschlangenelemente gemäß den ASCII-Werten sortiert.
Nachfolgend sind einige der Hauptmerkmale der PriorityQueue aufgeführt:
- PriorityQueue ist eine ungebundene Warteschlange.
- PriorityQueue erlaubt keine Nullwerte.
- Für nicht vergleichbare Objekte können wir keine Prioritätswarteschlange erstellen.
- PriorityQueue erbt von Klassen wie AbstractQueue, AbstractCollection, Collection und Object.
- Der Kopf oder die Vorderseite der Warteschlange enthält das kleinste Element gemäß der natürlichen Reihenfolge.
- Die Implementierung der Prioritätswarteschlange ist nicht threadsicher. Wenn wir also einen synchronisierten Zugriff wünschen, sollten wir die PriorityBlockingQueue verwenden.
Die PriorityQueue-Klasse erbt die Java Queue-Schnittstelle und ist Teil des Pakets java.util.
Die allgemeine Deklaration der PriorityQueue-Klasse ist unten angegeben:
public class PriorityQueue extends AbstractQueue implements Serializable
Das folgende Diagramm zeigt die Klassenhierarchie für die PriorityQueue-Klasse.
Zeitliche Komplexität der Prioritätswarteschlange
- Die zeitliche Komplexität der Prioritätswarteschlange für Einfügemethoden (Enqueue) und Löschmethoden (Dequeue) beträgt O (log (n)).
- Die Prioritätswarteschlange hat eine lineare Zeitkomplexität zum Entfernen und enthält Methoden.
- Die Methoden zum Abrufen von Elementen der Prioritätswarteschlange weisen eine konstante zeitliche Komplexität auf.
Beispiel für eine Prioritätswarteschlange In Java
Das folgende Programm zeigt eine einfache PriorityQueue in Java. Wir erstellen ein Objekt der PriorityQueue-Klasse, fügen Werte hinzu und zeigen dann den Inhalt der Warteschlange mit Iterator an.
import java.util.*; class Main{ public static void main(String args[]){ PriorityQueue cities_queue=new PriorityQueue(); //initialize the PriorityQueue with values cities_queue.add('Sydney'); cities_queue.add('Venice'); cities_queue.add('New York'); cities_queue.add('California'); cities_queue.add('Melbourne'); //print the head of the PriorityQueue System.out.println('PriorityQueue Head:'+cities_queue.element()); //Define the iterator for PriorityQueue and print its elements System.out.println('
PriorityQueue contents:'); Iterator iter=cities_queue.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }
Ausgabe:
Java Priority Queue API-Methoden
Konstruktoren:
Konstruktor-Prototyp | Beschreibung | |
---|---|---|
spähen | E peek () | Gibt den Kopf der Warteschlange zurück, ohne das Element zu löschen. |
Prioritätswarteschlange () | Ein Standardkonstruktor, der ein PriorityQueue-Objekt mit der Anfangskapazität 1 erstellt. | |
PriorityQueue (Sammlung c) | Erstellt ein PriorityQueue-Objekt mit Anfangselementen aus einer bestimmten Sammlung. C. | |
PriorityQueue (int initialCapacity) | Erstellt ein PriorityQueue-Objekt mit der angegebenen 'initialCapacity'. Die Elemente werden gemäß der natürlichen Reihenfolge bestellt. | |
PriorityQueue (int initialCapacity, Komparator-Komparator) | Erstellt ein PriorityQueue-Objekt mit der angegebenen 'initialCapacity'. Die Elemente sind nach dem angegebenen Komparator geordnet. | |
PriorityQueue (PriorityQueue c) | Erstellt ein PriorityQueue-Objekt aus einem anderen PriorityQueue-Objekt, das von c angegeben wird. | |
PriorityQueue (SortedSet c) | Erstellt ein PriorityQueue-Objekt aus einem SortedSet von c. |
Methoden
Methode | Methodenprototyp | Beschreibung |
---|---|---|
hinzufügen | Boolesches Addieren (E e) | Fügt der PriorityQueue das Element e hinzu. |
klar | void clear () | Löscht die PriorityQueue, indem alle Elemente gelöscht werden. |
Komparator | Komparatorcomparator () | Gibt einen benutzerdefinierten Komparator zurück, der für die Reihenfolge der Elemente in der Warteschlange verwendet wird. |
enthält | Boolescher Wert enthält (Objekt o) | Überprüft, ob die PriorityQueue das angegebene Element o enthält. Gibt true zurück, wenn ja. |
Iterator | Iteratoriterator () | Methode zum Abrufen eines Iterators für die angegebene PriorityQueue. |
Angebot | Boolesches Angebot (E e) | Fügen Sie das angegebene Element e in die PriorityQueue ein. |
Umfrage | E Umfrage () | Entfernt den Kopf der Warteschlange und gibt ihn zurück. Gibt null zurück, wenn die Warteschlange leer ist. |
entfernen | boolean remove (Objekt o) | Entfernt eine Instanz eines bestimmten Elements o, wenn es in der Warteschlange vorhanden ist. |
Größe | int size () | Gibt die Größe oder Anzahl der Elemente in dieser PriorityQueue zurück. |
toArray | Objekt [] toArray () | Gibt eine Array-Darstellung der angegebenen PriorityQueue zurück. |
toArray | T [] toArray (T [] a) | Gibt eine Array-Darstellung für die angegebene Prioritätswarteschlange mit demselben Laufzeittyp wie das angegebene Array zurück. A. |
Implementierung in Java
Lassen Sie uns die oben genannten Methoden von PriorityQueue mit einem Java-Programm demonstrieren.
import java.util.*; class Main { public static void main(String args[]) { // Creating empty priority queue PriorityQueue numQueue = new PriorityQueue(); // add elements to numQueue using add() numQueue.add('Five'); numQueue.add('One'); numQueue.add('Seven'); numQueue.add('Three'); numQueue.add('Eleven'); numQueue.add('Nine'); // Print the head element using Peek () method System.out.println('Head element using peek method:' + numQueue.peek()); // Printing all elements System.out.println('
The PriorityQueue elements:'); Iterator iter1 = numQueue.iterator(); while (iter1.hasNext()) System.out.print(iter1.next() + ' '); // remove head with poll () numQueue.poll(); System.out.println('
After removing an element' + 'with poll function:'); Iterator iter2 = numQueue.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); // Remove 'Three' using remove () numQueue.remove('Three'); System.out.println('
Element 'Three' with' + ' remove function:'); Iterator iter3 = numQueue.iterator(); while (iter3.hasNext()) System.out.print(iter3.next() + ' '); // Check if an element is present in PriorityQueue using contains() boolean ret_val = numQueue.contains('Five'); System.out.println('
Priority queue contains 'Five' ' + 'or not?: ' + ret_val); // get array equivalent of PriorityQueue with toArray () Object[] numArr = numQueue.toArray(); System.out.println('
Array Contents: '); for (int i = 0; i Ausgabe:
Was kann .swf-Dateien abspielen
Prioritätswarteschlange In Java 8
Java 8 fügt der PriorityQueue-Klasse eine weitere Methode hinzu, d. H. 'Spliterator ()'.
Die Details dieser Methode sind unten angegeben.
Methodenname: Splitter
Methodenprototyp: public final Spliterator spliterator ()
Methodenbeschreibung: Diese Methode erstellt einen Spliterator über den PriorityQueue-Elementen. Dieser Spliterator ist spät bindend und ausfallsicher.
Priority Queue Comparator
Wie bereits erwähnt, sind PriorityQueue-Elemente natürlich geordnet. Wenn wir die Reihenfolge ändern möchten, sollten wir einen Komparator angeben und ihn während der Erstellung des PriorityQueue-Objekts verwenden. Die PriorityQueue verwendet dann diesen Komparator, um ihre Elemente zu ordnen.
Das folgende Java-Programm demonstriert die Verwendung eines benutzerdefinierten Komparators für die Elementreihenfolge. In diesem Programm definieren wir einen neuen benutzerdefinierten Komparator, in dem wir die Vergleichsmethode überschreiben. Die Vergleichsmethode wird verwendet, um die Elemente der PriorityQueue entsprechend der Länge zu ordnen.
import java.util.*; public class Main { public static void main(String[] args) { // A custom comparator that compares two Strings by their length. Comparator customComparator = new Comparator() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); } }; // Create a Priority Queue with a custom Comparator PriorityQueue colorsPriorityQueue = new PriorityQueue(customComparator); // Add items to a Priority Queue colorsPriorityQueue.add('Red'); colorsPriorityQueue.add('Green'); colorsPriorityQueue.add('Blue'); colorsPriorityQueue.add('Cyan'); colorsPriorityQueue.add('Magenta'); colorsPriorityQueue.add('Yellow'); // Printing all elements System.out.println('
The PriorityQueue elements with custom Comparator:'); Iterator iter1 = colorsPriorityQueue.iterator(); while (iter1.hasNext()) System.out.print(iter1.next() + ' '); } }
Ausgabe:
Warteschlange mit minimaler Priorität in Java
Die natürliche Reihenfolge der Prioritätswarteschlange hat das kleinste oder kleinste Element am Kopf der Warteschlange und daher ist die Reihenfolge aufsteigend. Dies wird als 'Min Priority Queue' mit aufsteigender Reihenfolge der Elemente bezeichnet.
Das folgende Java-Programm zeigt die Implementierung der Min Priority Queue in Java.
import java.util.*; class Main{ public static void main(String args[]){ //declare a PriorityQueue object with default ordering PriorityQueue pq = new PriorityQueue(); //add element to the PriorityQueue pq.add(8); pq.add(6); pq.add(4); pq.add(2); pq.add(12); pq.add(10); //display the min PriorityQueue System.out.println('The min Priority Queue (natural ordering) contents:'); Integer val = null; while( (val = pq.poll()) != null) { System.out.print(val + ' '); } } }
Ausgabe:
Warteschlange mit maximaler Priorität in Java
Während die Warteschlange mit minimaler Priorität Elemente in aufsteigender Reihenfolge enthält, enthält die Warteschlange mit maximaler Priorität die Elemente in absteigender Reihenfolge, d. H. Der Kopf der Warteschlange mit maximaler Priorität gibt das größte Element in der Warteschlange zurück.
Das folgende Java-Programm demonstriert die Max Priority Queue in Java.
import java.util.*; class Main{ public static void main(String args[]){ //declare a PriorityQueue object with custom comparator to generate max PQ PriorityQueue pq = new PriorityQueue(new Comparator() { public int compare(Integer lhs, Integer rhs) { if (lhs Ausgabe:
wie man eine .bin-Datei ausführt
Wie im obigen Programm gezeigt, müssen wir einen benutzerdefinierten Komparator definieren, um die natürliche Reihenfolge der Elemente in der Prioritätswarteschlange zu ändern.
Häufig gestellte Fragen
F # 1) Was ist die Prioritätswarteschlange in Java?
Antworten: Eine spezielle Warteschlange, in der alle Elemente der Warteschlange gemäß der natürlichen Reihenfolge oder unter Verwendung eines benutzerdefinierten Komparators sortiert sind, wird als Prioritätswarteschlange bezeichnet. Es folgt nicht der FIFO-Reihenfolge.
F # 2) Wie legen Sie eine Warteschlange mit maximaler Priorität in Java fest?
Antworten: Wir können eine Warteschlange mit maximaler Priorität in Java mithilfe eines benutzerdefinierten Komparators festlegen, sodass der Kopf der Warteschlange das größte Element in der Warteschlange zurückgibt.
F # 3) Erlaubt die Prioritätswarteschlange Duplikate von Java?
Antworten: Ja. Die Prioritätswarteschlange ermöglicht doppelte Werte.
F # 4) Ist die Java-Prioritätswarteschlange maximal oder minimal?
Antworten: Standardmäßig ist die Prioritätswarteschlange in Java die min. Prioritätswarteschlange mit natürlicher Reihenfolge. Um das Maximum zu erreichen, müssen wir einen benutzerdefinierten Komparator verwenden, damit der Kopf der Warteschlange das größte Element in der Warteschlange zurückgibt.
F # 5) Ist eine Prioritätswarteschlange sortiert?
Antworten: Standardmäßig ist der Kopf der Warteschlange sortiert und die Prioritätswarteschlange hat das kleinste Element als Kopf. Der Rest der Elemente wird bei Bedarf bestellt.
Fazit
Damit ist das Lernprogramm zu Prioritätswarteschlangen in Java abgeschlossen. Die Prioritätswarteschlange implementiert eine Warteschlangenschnittstelle und ist eine spezielle Warteschlange, in der Elemente gemäß der natürlichen Reihenfolge sortiert werden. Es folgt nicht der FIFO-Reihenfolge. Um die natürliche Reihenfolge der Prioritätswarteschlange zu ändern, können wir den benutzerdefinierten Komparator verwenden.
Prioritätswarteschlangen werden hauptsächlich für die Druckerplanung, die CPU-Taskplanung usw. verwendet. Der Heap (min oder max) wird auch mithilfe von Prioritätswarteschlangen implementiert.
=> Lesen Sie die Easy Java Training Series durch.
Literatur-Empfehlungen
- Datenstruktur der Prioritätswarteschlange in C ++ mit Abbildung
- Prioritätswarteschlange In STL
- Java Queue - Warteschlangenmethoden, Warteschlangenimplementierung mit Beispielen
- C ++ Circular Queue-Datenstruktur: Implementierung und Anwendungen
- Double Ended Queue (Deque) in C ++ mit Beispielen
- Warteschlangendatenstruktur in C ++ mit Illustration
- Stapel und Warteschlangen in STL
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials