java priority queue tutorial implementation examples
Tento kurz vysvětluje prioritní frontu prostředí Java a související koncepty, jako je komparátor, minimální a maximální prioritní fronta, spolu s její implementací s příklady:
Datová struktura prioritní fronty je speciální fronta, ve které jsou prvky přítomny nikoli podle pořadí FIFO, ale podle přírodních prvků nebo jakéhokoli vlastního komparátoru použitého při vytváření fronty.
=> Prohlédněte si příručku Java Beginners Guide zde.
Co se naučíte:
Prioritní fronta v Javě
V prioritní frontě má přední část fronty nejméně prvků podle přirozeného řazení a zadní část směřuje k největšímu prvku ve frontě.
Níže je uveden příklad prioritní fronty skládající se z čísel.
Algoritmus třídění vkládání v C ++
Když je tedy prvek odebrán z prioritní fronty zobrazené výše, bude to nejméně prvek.
Podobně u fronty s abecední prioritou budou brány v úvahu hodnoty ASCII a prvky fronty budou seřazeny podle hodnot ASCII.
Níže jsou uvedeny některé z hlavních charakteristik PriorityQueue:
- PriorityQueue je nevázaná fronta.
- PriorityQueue neumožňuje hodnoty null.
- U nesrovnatelných objektů nemůžeme vytvořit prioritní frontu.
- PriorityQueue dědí z tříd jako AbstractQueue, AbstractCollection, Collection a Object.
- Hlava nebo přední strana fronty obsahuje nejmenší prvek podle přirozeného řazení.
- Implementace prioritní fronty není bezpečná pro vlákna. Pokud tedy požadujeme synchronizovaný přístup, měli bychom použít PriorityBlockingQueue.
Třída PriorityQueue dědí rozhraní Java Queue Interface a je součástí balíčku java.util.
Obecná deklarace třídy PriorityQueue je uvedena níže:
public class PriorityQueue extends AbstractQueue implements Serializable
Níže uvedený diagram ukazuje hierarchii tříd pro třídu PriorityQueue.
Časová složitost prioritní fronty
- Časová složitost prioritní fronty pro metody vložení (zařazení do fronty) a odstranění (odstranění fronty) je O (log (n)).
- Prioritní fronta má lineární časovou složitost pro odstranění a obsahuje metody.
- Metody, které načítají prvky prioritní fronty, mají stálou časovou složitost.
Příklad prioritní fronty v Javě
Níže uvedený program ukazuje jednoduchou PriorityQueue v Javě. Vytvoříme objekt třídy PriorityQueue, přidáme do něj hodnoty a poté zobrazíme obsah fronty pomocí Iterátoru.
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() + ' '); } } }
Výstup:
Metody API prioritní fronty Java
Konstruktéři:
Prototyp konstruktoru | Popis | |
---|---|---|
nahlédnout | E nahlédnout () | Vrátí záhlaví fronty bez odstranění prvku. |
PriorityQueue () | Výchozí konstruktor, který vytvoří objekt PriorityQueue s počáteční kapacitou 1. | |
PriorityQueue (kolekce c) | Vytvoří objekt PriorityQueue s počátečními prvky z dané kolekce c. | |
PriorityQueue (int initialCapacity) | Vytvoří objekt PriorityQueue s danou ‚initialCapacity '. Prvky jsou seřazeny podle přirozeného řazení. | |
PriorityQueue (int initialCapacity, komparátor komparátor) | Vytvoří objekt PriorityQueue s danou ‚initialCapacity '. Prvky jsou seřazeny podle daného komparátoru. | |
PriorityQueue (PriorityQueue c) | Vytvoří objekt PriorityQueue z jiného objektu PriorityQueue daného c. | |
PriorityQueue (SortedSet c) | Vytvoří objekt PriorityQueue ze SortedSet dané c. |
Metody
Metoda | Metoda Prototyp | Popis |
---|---|---|
přidat | booleovský doplněk (E e) | Přidá prvek e do PriorityQueue. |
Průhledná | prázdnota clear () | Vymaže PriorityQueue odstraněním všech prvků. |
komparátor | Comparatorcomparator () | Vrátí vlastní komparátor použitý pro řazení prvků ve frontě. |
obsahuje | boolean obsahuje (Objekt o) | Zkontroluje, zda PriorityQueue obsahuje daný prvek o. Vrátí true, pokud ano. |
iterátor | Iteratoriterator () | Metoda získání iterátoru pro danou PriorityQueue. |
nabídka | booleovská nabídka (E e) | Vložte daný prvek e do PriorityQueue. |
hlasování | E hlasování () | Odebere a vrátí hlavu fronty. Vrátí hodnotu null, pokud je fronta prázdná. |
odstranit | boolean remove (Objekt o) | Odebere instanci daného prvku o, pokud je ve frontě. |
velikost | int velikost () | Vrátí velikost nebo počet prvků v této PriorityQueue. |
toArray | Objekt [] toArray () | Vrátí reprezentaci pole dané PriorityQueue. |
toArray | T [] toArray (T [] a) | Vrátí reprezentaci pole pro danou prioritní frontu se stejným typem běhu jako zadané pole a. |
Implementace v Javě
Ukážeme si výše uvedené metody PriorityQueue pomocí programu Java.
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 Výstup:
jak vyvinout java aplikaci v zatmění
Prioritní fronta v Javě 8
Java 8 přidává do třídy PriorityQueue ještě jednu metodu, tj. „Spliterator ()“.
Podrobnosti o této metodě jsou uvedeny níže.
Název metody: rozdělovač
Prototyp metody: veřejný finální Spliterator spliterator ()
Popis metody: Tato metoda vytvoří rozdělovač nad prvky PriorityQueue. Tento rozdělovač má pozdní vazbu a rychlé selhání.
Porovnávač prioritních front
Jak již bylo zmíněno, prvky PriorityQueue jsou přirozeně seřazeny. Pokud chceme změnit řazení, měli bychom určit komparátor a použít jej při vytváření objektu PriorityQueue. PriorityQueue pak použije tento komparátor k objednání svých prvků.
Níže uvedený program Java demonstruje použití vlastního komparátoru pro řazení prvků. V tomto programu definujeme nový vlastní komparátor, ve kterém přepíšeme metodu „porovnání“. Porovnávací metoda se používá k uspořádání prvků PriorityQueue podle délky.
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() + ' '); } }
Výstup:
Min. Prioritní fronta v Javě
Přirozené řazení prioritní fronty má nejmenší nebo nejmenší prvek v čele fronty, a proto je řazení vzestupné. Tomu se říká „fronta minimální priority“ se vzestupným uspořádáním prvků.
Níže uvedený program Java ukazuje implementaci fronty minimální priority v Javě.
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 + ' '); } } }
Výstup:
Max. Prioritní fronta v Javě
Zatímco fronta s minimální prioritou má prvky ve vzestupném pořadí, fronta s maximální prioritou má prvky v sestupném pořadí, tj. Hlava fronty s prioritou Max vrátí největší prvek ve frontě.
Níže uvedený program Java demonstruje Max Priority Queue v Javě.
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 Výstup:
Jak je uvedeno ve výše uvedeném programu, abychom mohli změnit přirozené řazení prvků ve frontě priorit, musíme definovat vlastní komparátor.
devops rozhovor otázky a odpovědi pro zkušené
Často kladené otázky
Otázka č. 1) Co je prioritní fronta v Javě?
Odpovědět: Speciální fronta, ve které jsou všechny prvky fronty seřazeny podle přirozeného uspořádání nebo pomocí vlastního komparátoru, se nazývá prioritní fronta. Nesleduje FIFO objednávku.
Otázka 2) Jak nastavíte frontu Max Priority v Javě?
Odpovědět: Můžeme nastavit Max Priority Queue v Javě pomocí vlastního komparátoru tak, aby hlava fronty vrátila největší prvek ve frontě.
Otázka č. 3) Umožňuje prioritní fronta duplikáty Javy?
Odpovědět: Ano. Prioritní fronta umožňuje duplicitní hodnoty.
Otázka č. 4) Je fronta priority Java maximální nebo minimální?
Odpovědět: Ve výchozím nastavení je prioritní fronta v Javě min. Prioritní fronta s přirozeným uspořádáním. Aby to bylo maximální, musíme použít vlastní komparátor, aby head fronty vrátil největší prvek ve frontě.
Otázka č. 5) Je seřazená prioritní fronta?
Odpovědět: Ve výchozím nastavení je hlava fronty tříděna a prioritní fronta má jako hlavu nejmenší prvek. Zbytek prvků je v případě potřeby objednán.
Závěr
Tím je dokončen kurz o prioritních frontách v Javě. Prioritní fronta implementuje rozhraní fronty a je speciální frontou, kde jsou prvky seřazeny podle přirozeného řazení. Nesleduje FIFO objednávku. Chcete-li změnit přirozené řazení prioritní fronty, můžeme použít vlastní komparátor.
Prioritní fronty se používají hlavně pro plánování tiskáren, plánování úloh CPU atd. Haldy (min. Nebo max.) Se také implementují pomocí prioritních front.
=> Přečtěte si řadu Easy Java Training Series.
Doporučené čtení
- Struktura dat prioritní fronty v C ++ s ilustrací
- Prioritní fronta v STL
- Fronta Java - metody fronty, implementace fronty s příklady
- Struktura dat kruhové fronty C ++: Implementace a aplikace
- Oboustranná fronta (Deque) v C ++ s příklady
- Struktura dat fronty v C ++ s ilustrací
- Zásobníky a fronty v STL
- Výukový program JAVA pro začátečníky: 100+ praktických výukových programů Java Video