java priority queue tutorial implementation examples
Denna handledning förklarar Java Priority Queue och relaterade begrepp som Comparator, Min och Max Priority Queue tillsammans med dess implementering med exempel:
Prioriteringskö datastruktur är en speciell kö där elementen inte finns enligt FIFO-order utan enligt de naturliga elementen eller vilken anpassad komparator som helst som används vid köskapande.
=> Ta en titt på Java-nybörjarguiden här.
Vad du kommer att lära dig:
Prioritetskö i Java
I Priority Queue har den främre delen av kön de minst elementen enligt den naturliga ordningen och den bakre pekas mot det största elementet i kön.
Ett exempel Prioritetskö bestående av siffror visas nedan.
bästa mp3-sångnedladdaren för android
När ett element tas bort från den prioritetskö som visas ovan blir det alltså det minst elementet.
På samma sätt kommer ASCII-värden att beaktas för en alfabetisk prioritetskö och köelementen kommer att ordnas enligt ASCII-värdena.
Nedan listas några av de viktigaste egenskaperna för PriorityQueue:
- PriorityQueue är en obunden kö.
- PriorityQueue tillåter inte nollvärden.
- För icke-jämförbara objekt kan vi inte skapa en prioritetskö.
- PriorityQueue ärver från klasserna som AbstractQueue, AbstractCollection, Collection och Object.
- Huvudet eller fronten på kön innehåller det minsta elementet enligt den naturliga ordningen.
- Prioriterad köimplementering är inte trådsäker. Således, om vi önskar synkroniserad åtkomst, bör vi använda PriorityBlockingQueue.
PriorityQueue-klassen ärver Java-kögränssnittet och är en del av paketet java.util.
Den allmänna deklarationen för klassen PriorityQueue ges nedan:
public class PriorityQueue extends AbstractQueue implements SerializableNedanstående diagram visar klasshierarkin för klassen PriorityQueue.
Tidskomplexitet i prioritetskön
- Tidskomplexiteten för Priority Queue för insättning (enqueue) och borttagning (dequeue) är O (log (n)).
- Prioritetskön har linjär tidskomplexitet för borttagning och innehåller metoder.
- Metoderna som hämtar element i Priority Queue har konstant tidskomplexitet.
Prioritetskösexempel i Java
Nedanstående program visar en enkel PriorityQueue i Java. Vi skapar ett objekt av klassen PriorityQueue, lägger till värden till det och visar sedan innehållet i kön med 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 prototyp | Beskrivning | |
|---|---|---|
| titt | E titt () | Returnerar köets huvud utan att ta bort elementet. |
| PriorityQueue () | En standardkonstruktör som skapar ett PriorityQueue-objekt med initial kapacitet som 1. | |
| PriorityQueue (samling c) | Skapar ett PriorityQueue-objekt med initiala element från en given samling c. | |
| PriorityQueue (int initialCapacity) | Skapar ett PriorityQueue-objekt med den givna ”initialCapacity”. Element beställs enligt naturlig beställning. | |
| PriorityQueue (int initialCapacity, Comparator comparator) | Skapar ett PriorityQueue-objekt med den givna ”initialCapacity”. Elementen ordnas enligt den givna komparatorn. | |
| PriorityQueue (PriorityQueue c) | Skapar ett PriorityQueue-objekt från ett annat PriorityQueue-objekt som ges av c. | |
| PriorityQueue (SortedSet c) | Skapar ett PriorityQueue-objekt från en SortedSet som ges av c. |
Metoder
| Metod | Metodprototyp | Beskrivning |
|---|---|---|
| Lägg till | boolesk tillsats (E e) | Lägger till element e i PriorityQueue. |
| klar | ogiltig rensa () | Rensar PriorityQueue genom att ta bort alla element. |
| jämförare | Comparatorcomparator () | Returnerar en anpassad komparator som används för beställning av element i kön. |
| innehåller | boolean innehåller (Objekt o) | Kontrollerar om PriorityQueue innehåller det givna elementet o. Returnerar sant om ja. |
| iterator | Iteratoriterator () | Metod för att få en iterator för den givna PriorityQueue. |
| erbjudande | booleskt erbjudande (E e) | Infoga givna element e i PriorityQueue. |
| opinionsundersökning | E-undersökning () | Tar bort och returnerar köets huvud. Returnerar null om kön är tom. |
| ta bort | boolean ta bort (Objekt o) | Tar bort en instans av ett visst element o om det finns i kön. |
| storlek | int storlek () | Returnerar storleken eller antalet element i denna PriorityQueue. |
| toArray | Objekt () toArray () | Returnerar en matrisrepresentation av den givna PriorityQueue. |
| toArray | T () toArray (T () a) | Returnerar en arrayrepresentation för den angivna prioritetskön med samma körtyp som den angivna matrisen a. |
Implementering i Java
Låt oss demonstrera ovanstående metoder för PriorityQueue med hjälp av ett 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:
förvandla char till int c ++
Prioritetskö i Java 8
Java 8 lägger till en metod till PriorityQueue-klassen, dvs. ”spliterator ()”.
Detaljerna i denna metod ges nedan.
Metodens namn: splitter
Metodprototyp: allmän final Spliterator spliterator ()
Metodbeskrivning: Denna metod skapar en spliterator över PriorityQueue-elementen. Denna spliterator är senbindande och felsnabb.
Prioriteringsköjämförare
Som redan nämnts ordnas naturligtvis PriorityQueue-element. Om vi vill ändra ordningen bör vi ange en komparator och använda den under skapandet av PriorityQueue-objektet. PriorityQueue använder sedan denna komparator för att beställa dess element.
Nedanstående Java-program visar användningen av anpassad komparator för beställning av element. I detta program definierar vi en ny anpassad komparator där vi åsidosätter metoden ”jämför”. Jämförelsemetoden används för att ordna elementen i PriorityQueue efter 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 naturliga beställningen av Priority Queue har det minsta eller minsta elementet i köets huvud och därmed stiger beställningen. Detta kallas 'Min prioritetskö' med stigande ordning på element.
Java-programmet nedan visar implementeringen av 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:
intervjufrågor och svar för mobil testning
Max prioritetskö i Java
Medan den minsta prioritetskön har element i stigande ordning, har den högsta prioritetskön elementen i fallande ordning, dvs. huvudet på Maxprioritetskön kommer att returnera det största elementet i kön.
Java-programmet nedan visar 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 visas i ovanstående program, för att ändra den naturliga ordningen av element i prioritetskön, måste vi definiera en anpassad komparator.
Vanliga frågor
F # 1) Vad är prioritetskön i Java?
Svar: En särskild kö där alla element i kön beställs enligt naturlig beställning eller med en anpassad komparator kallas Priority-kön. Det följer inte FIFO-ordern.
F # 2) Hur ställer du in en maximal prioritetskö i Java?
Svar: Vi kan ställa in en maximal prioritetskö i Java med hjälp av en anpassad komparator så att köhuvudet returnerar det största elementet i kön.
F # 3) Tillåter Priority-kön dubbletter av Java?
Svar: Ja. Prioritetskö tillåter dubbla värden.
F # 4) Är Java Priority-kö max eller min?
Svar: Som standard är prioritetskön i Java min Prioritetskö med naturlig ordning. För att göra det maximalt måste vi använda en anpassad komparator så att köhuvudet returnerar det största elementet i kön.
F # 5) Sorteras en prioritetskö?
Svar: Som standard sorteras köhuvudet och prioritetskön har minst element som huvud. Resten av elementen beställs vid behov.
Slutsats
Detta slutför självstudien om prioritetsköer i Java. Priority Queue implementerar ett kögränssnitt och är en speciell kö där element ordnas enligt naturlig beställning. Det följer inte FIFO-ordern. För att ändra den naturliga ordningen för prioritetskön kan vi använda den anpassade komparatorn.
Prioritetsköer används huvudsakligen för schemaläggning av skrivare, CPU-schemaläggning etc. Heapen (min eller max) implementeras också med Priority Queues.
=> Läs igenom Easy Java Training Series.
Rekommenderad läsning
- Prioriterad köstruktur i C ++ med illustration
- Prioritetskö i STL
- Java-kö - kömetoder, köimplementering med exempel
- C ++ Circular Queue Data Structure: Implementation & Applications
- Double Ended Queue (Deque) I C ++ med exempel
- Kodatastruktur i C ++ med illustration
- Travar och köer i STL
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
