java priority queue tutorial implementation examples
Denne vejledning forklarer Java Priority Queue og relaterede begreber som Comparator, Min og Max Priority Queue sammen med dens implementering med eksempler:
Prioritetskø-datastruktur er en særlig kø, hvor elementerne ikke er til stede i henhold til FIFO-rækkefølge, men i henhold til de naturlige elementer eller enhver brugerdefineret komparator, der bruges under oprettelse af kø.
=> Se på Java Beginners Guide her.
Hvad du vil lære:
Prioritetskø i Java
I prioritetskøen har køens forreste de færreste elementer i henhold til den naturlige rækkefølge, og den bageste er peget på det største element i køen.
Et eksempel på prioritetskø bestående af tal er vist nedenfor.
sql forespørgsler til praksis med svar
Når et element fjernes fra prioritetskøen vist ovenfor, vil det således være det mindste element.
Tilsvarende overvejes ASCII-værdier for en alfabetisk prioritetskø, og køelementerne bestilles i henhold til ASCII-værdierne.
Nedenfor er nogle af de vigtigste karakteristika ved PriorityQueue:
- PriorityQueue er en ubundet kø.
- PriorityQueue tillader ikke nulværdier.
- For ikke-sammenlignelige objekter kan vi ikke oprette en prioritetskø.
- PriorityQueue arver fra klasser som AbstractQueue, AbstractCollection, Collection og Object.
- Hovedet eller forsiden af køen indeholder det mindste element i henhold til den naturlige rækkefølge.
- Prioriteringskøimplementering er ikke trådsikker. Således hvis vi ønsker synkroniseret adgang, skal vi bruge PriorityBlockingQueue.
PriorityQueue-klassen arver Java Queue Interface og er en del af java.util-pakken.
Den generelle erklæring fra PriorityQueue-klassen er angivet nedenfor:
public class PriorityQueue extends AbstractQueue implements SerializableNedenstående diagram viser klassehierarkiet for klassen PriorityQueue.
Tidskompleksitet af prioritetskø
- Tidskompleksiteten af Priority Queue til indsættelse (enqueue) og sletning (dequeue) metoder er O (log (n)).
- Prioritetskø har lineær tidskompleksitet til fjernelse og indeholder metoder.
- Metoderne, der henter elementer i Priority Queue, har konstant tidskompleksitet.
Eksempel på prioritetskø i Java
Nedenstående program viser en simpel PriorityQueue i Java. Vi opretter et objekt af PriorityQueue-klassen, tilføjer værdier til det og viser derefter indholdet af køen ved hjælp af Iterator.
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() + ' '); } } } Produktion:
Java Priority Queue API-metoder
Konstruktører:
| Konstruktør prototype | Beskrivelse | |
|---|---|---|
| kigge | E kigger () | Returnerer køens hoved uden at slette elementet. |
| PriorityQueue () | En standardkonstruktør, der opretter et PriorityQueue-objekt med startkapacitet som 1. | |
| PriorityQueue (samling c) | Opretter et PriorityQueue-objekt med indledende elementer fra den givne samling c. | |
| PriorityQueue (int initialCapacity) | Opretter et PriorityQueue-objekt med den givne 'initialCapacity'. Elementer bestilles efter naturlig bestilling. | |
| PriorityQueue (int initialCapacity, Comparator comparator) | Opretter et PriorityQueue-objekt med den givne 'initialCapacity'. Elementerne er ordnet i henhold til den givne komparator. | |
| PriorityQueue (PriorityQueue c) | Opretter et PriorityQueue-objekt fra et andet PriorityQueue-objekt givet af c. | |
| PriorityQueue (SortedSet c) | Opretter et PriorityQueue-objekt ud fra et SortedSet givet af c. |
Metoder
| Metode | Metode Prototype | Beskrivelse |
|---|---|---|
| tilføje | boolsk tilføjelse (E e) | Føjer element e til PriorityQueue. |
| klar | ugyldigt klart () | Rydder PriorityQueue ved at slette alle elementerne. |
| komparator | Comparatorcomparator () | Returnerer en brugerdefineret komparator, der bruges til bestilling af elementer i køen. |
| indeholder | boolean indeholder (Objekt o) | Kontrollerer, om PriorityQueue indeholder det givne element o. Returnerer sandt, hvis ja. |
| iterator | Iteratoriterator () | Metode til at få en iterator til den givne PriorityQueue. |
| tilbud | boolsk tilbud (E e) | Indsæt givet element e i PriorityQueue. |
| afstemning | E afstemning () | Fjerner og returnerer køens hoved. Returnerer nul, hvis køen er tom. |
| fjerne | boolsk fjernelse (Objekt o) | Fjerner en forekomst af et givet element o, hvis det findes i køen. |
| størrelse | int størrelse () | Returnerer størrelsen eller antallet af elementer i denne PriorityQueue. |
| toArray | Objekt () toArray () | Returnerer en matrixrepræsentation af den givne PriorityQueue. |
| toArray | T () toArray (T () a) | Returnerer en matrixrepræsentation for den givne prioritetskø med den samme runtime-type som den specificerede matrix a. |
Implementering i Java
Lad os demonstrere ovenstående metoder til PriorityQueue ved hjælp af et Java-program.
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 Produktion:
hvad er den bedste computerrenser gratis?
Prioritetskø i Java 8
Java 8 tilføjer endnu en metode til PriorityQueue-klassen, dvs. 'spliterator ()'.
Detaljerne i denne metode er angivet nedenfor.
Metodenavn: splitter
Metode prototype: offentlig endelig Spliterator spliterator ()
Metode Beskrivelse: Denne metode opretter en spliterator over PriorityQueue-elementerne. Denne spliterator er senbindende og fejler hurtigt.
Prioritetskø-komparator
Som allerede nævnt bestilles PriorityQueue-elementer naturligt. Hvis vi vil ændre rækkefølgen, skal vi angive en komparator og bruge den under oprettelsen af objektet PriorityQueue. PriorityQueue bruger derefter denne komparator til at bestille dens elementer.
Nedenstående Java-program viser brugen af brugerdefineret komparator til elementbestilling. I dette program definerer vi en ny brugerdefineret komparator, hvori vi tilsidesætter 'sammenligne'-metoden. Sammenligningsmetoden bruges til at ordne elementerne i PriorityQueue i henhold til længden.
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() + ' '); } } Produktion:
Min prioritetskø i Java
Den naturlige rækkefølge af Priority Queue har det mindste eller mindste element i køens hoved, og rækkefølgen stiger således. Dette kaldes 'Min prioritetskø' med stigende rækkefølge af elementer.
Java-programmet nedenfor viser implementeringen af Min Priority Queue i 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 + ' '); } } } Produktion:
Maks prioritetskø i Java
Mens min-prioritetskøen har elementer i stigende rækkefølge, har den maksimale prioritetskø elementerne i faldende rækkefølge, dvs. hovedet på den maksimale prioritetskø vil returnere det største element i køen.
Java-programmet nedenfor viser Max Priority Queue i 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 Produktion:
Som vist i ovenstående program skal vi definere en brugerdefineret komparator for at ændre den naturlige rækkefølge af elementer i prioritetskøen.
Ofte stillede spørgsmål
Q # 1) Hvad er prioritetskøen i Java?
Svar: En særlig kø, hvor alle elementerne i køen bestilles i henhold til naturlig bestilling eller ved hjælp af en brugerdefineret komparator, kaldes Priority-køen. Det følger ikke FIFO-ordren.
Spørgsmål nr. 2) Hvordan indstiller du en Max Priority-kø i Java?
Svar: Vi kan indstille en maksimal prioritetskø i Java ved hjælp af en brugerdefineret komparator, så køens hoved returnerer det største element i køen.
Q # 3) Tillader Priority-køen duplikater Java?
Svar: Ja. Prioritetskø tillader duplikerede værdier.
apk filplacering i Android-telefon
Q # 4) Er Java Priority-kø maks eller min?
Svar: Som standard er prioritetskøen i Java min Prioritetskø med naturlig rækkefølge. For at gøre det maksimalt skal vi bruge en brugerdefineret komparator, så køhovedet returnerer det største element i køen.
Q # 5) Er en prioritetskø sorteret?
Svar: Som standard sorteres køens hoved, og prioritetskøen har det mindste element som hoved. Resten af elementerne bestilles efter behov.
Konklusion
Dette afslutter selvstudiet om prioritetskøer i Java. Prioritetskø implementerer en køgrænseflade og er en speciel kø, hvor elementer bestilles pr. Naturlig bestilling. Det følger ikke FIFO-ordren. For at ændre den naturlige rækkefølge af prioritetskøen kan vi bruge den tilpassede komparator.
Prioritetskøer bruges hovedsageligt til printerplanlægning, CPU-opgaveplanlægning osv. Heapen (min eller max) implementeres også ved hjælp af Priority Queues.
=> Læs gennem Easy Java Training Series.
Anbefalet læsning
- Prioriteret kødatastruktur i C ++ med illustration
- Prioritetskø i STL
- Java-kø - kømetoder, køimplementering med eksempler
- C ++ Cirkulær kø Datastruktur: Implementering og applikationer
- Dobbelt afsluttet kø (Deque) i C ++ med eksempler
- Kø Datastruktur i C ++ med illustration
- Stakke og køer i STL
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
