జావా ప్రాధాన్యత క్యూ: క్లాసికల్ క్యూ కాదు

ఈ ఆర్టికల్‌లో క్యూ ఇంటర్‌ఫేస్‌ని అమలు చేసే జావా క్లాస్ అనే ప్రాధాన్య క్యూను మనం నేర్చుకుంటాము. సాధారణ క్యూ ఇంటర్‌ఫేస్ గురించి ప్రోగ్రామర్‌కు ఏమి తెలుసు? అన్నింటిలో మొదటిది, ఈ ఇంటర్‌ఫేస్ FIFO సూత్రం లేదా "ఫస్ట్ ఇన్ ఫస్ట్ అవుట్" ఆధారంగా రూపొందించబడింది. ఇది సాధారణ క్యూను దాని సాధారణ అర్థంలో గుర్తు చేస్తుంది. మీరు McDrive నుండి కాఫీ పొందాలనుకుంటున్నారా? మీ కారు కిటికీకి సమీపంలో మొదటిది అయితే, మీరు పక్కన ఉన్న డ్రైవర్ కంటే ముందుగా మీ కాఫీని అందుకుంటారు.

క్యూ ఇంటర్‌ఫేస్ డిక్లరేషన్

public interface Queue<E> extends Collection<E>

ప్రాధాన్యత క్యూ అంటే ఏమిటి

ప్రాధాన్యత క్యూ అంటే ఏమిటి? అన్నింటిలో మొదటిది, ఇది వెనుక నుండి ఒక మూలకాన్ని చొప్పించినప్పుడు మరియు తల నుండి ఒక మూలకాన్ని తీసివేసినప్పుడు క్యూ ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతి. అయితే లోపల మామూలు క్యూ కాదు. జావా ప్రాధాన్యత క్యూ మూలకాల క్రమం మూలకాల ప్రాధాన్యతపై ఆధారపడి ఉంటుంది. అత్యధిక ప్రాధాన్యత కలిగిన మూలకం క్యూ యొక్క తలపైకి తరలించబడుతుంది. మీరు అత్యధిక ర్యాంక్ ఉన్న మూలకాన్ని తొలగిస్తే (సర్వ్ చేస్తే), రెండవది దాని కాఫీని పొందడానికి తలపైకి వెళుతుంది. ప్రాధాన్యత ఎలా నిర్ణయించబడుతుంది? డాక్యుమెంటేషన్ ప్రకారం, ప్రాధాన్యత క్యూ యొక్క మూలకాలు వాటి సహజ క్రమానికి అనుగుణంగా లేదా క్యూ నిర్మాణ సమయంలో అందించబడిన కంపారిటర్ ద్వారా ఏ కన్స్ట్రక్టర్‌ని ఉపయోగించబడుతుందో బట్టి ఆర్డర్ చేయబడతాయి. ప్రాధాన్య నిమి హీప్ ఆధారంగా ప్రాధాన్య క్యూ. అంటే, సంఖ్యల క్యూ మూలకాల విషయంలో, క్యూలోని మొదటి మూలకం ఈ సంఖ్యలలో కనిష్టంగా ఉంటుంది. చాలా తరచుగా ఈ నిర్వచనం చదివిన తర్వాత రూకీ విద్యార్థులు ప్రాధాన్యత క్యూ సరళ కోణంలో క్రమబద్ధీకరించబడిందని ఆలోచించడం ప్రారంభిస్తారు. అంటే, మనం సహజ సంఖ్యలుగా ఉన్న క్యూను ఉపయోగిస్తే, మొదటి మూలకం చిన్నది మరియు చివరిది - పెద్దది. ఇది పూర్తిగా నిజం కాదు. ప్రాధాన్యత క్యూ వాస్తవానికి ఎలా పని చేస్తుందో మరియు అది ఏమి ఇస్తుందో అర్థం చేసుకోవడానికి, మీరు కుప్ప ఎలా పని చేస్తుందో గుర్తించాలి. మేము కొంచెం తర్వాత ఉదాహరణను ఉపయోగించి ప్రాధాన్యత క్యూ యొక్క అంతర్గత నిర్మాణాన్ని పరిశీలిస్తాము. ఇప్పుడు దాని బాహ్య లక్షణాలపై నివసిద్దాం. అప్పుడు మొదటి మూలకం చిన్నది, మరియు చివరిది - అతిపెద్దది. ఇది పూర్తిగా నిజం కాదు. ప్రాధాన్యత క్యూ వాస్తవానికి ఎలా పని చేస్తుందో మరియు అది ఏమి ఇస్తుందో అర్థం చేసుకోవడానికి, మీరు కుప్ప ఎలా పని చేస్తుందో గుర్తించాలి. మేము కొంచెం తర్వాత ఉదాహరణను ఉపయోగించి ప్రాధాన్యత క్యూ యొక్క అంతర్గత నిర్మాణాన్ని పరిశీలిస్తాము. ఇప్పుడు దాని బాహ్య లక్షణాలపై నివసిద్దాం. అప్పుడు మొదటి మూలకం చిన్నది, మరియు చివరిది - అతిపెద్దది. ఇది పూర్తిగా నిజం కాదు. ప్రాధాన్యత క్యూ వాస్తవానికి ఎలా పని చేస్తుందో మరియు అది ఏమి ఇస్తుందో అర్థం చేసుకోవడానికి, మీరు కుప్ప ఎలా పని చేస్తుందో గుర్తించాలి. మేము కొంచెం తర్వాత ఉదాహరణను ఉపయోగించి ప్రాధాన్యత క్యూ యొక్క అంతర్గత నిర్మాణాన్ని పరిశీలిస్తాము. ఇప్పుడు దాని బాహ్య లక్షణాలపై నివసిద్దాం.

ప్రాధాన్యత క్యూ క్లాస్ కన్‌స్ట్రక్టర్‌లు మరియు డిక్లరేషన్

PriorityQueue క్లాస్ జావాలో ప్రాధాన్యత క్యూను నిర్మించడానికి 6 విభిన్న మార్గాలను అందిస్తుంది.

• PriorityQueue() - డిఫాల్ట్ ప్రారంభ సామర్థ్యంతో ఖాళీ క్యూ (11) దాని మూలకాలను వాటి సహజ క్రమం ప్రకారం ఆర్డర్ చేస్తుంది.
• ప్రాధాన్యత క్యూ(కలెక్షన్ సి) - పేర్కొన్న సేకరణలోని మూలకాలను కలిగి ఉన్న ఖాళీ క్యూ.
• PriorityQueue(int initialCapacity) - దాని మూలకాలను వాటి సహజ క్రమానికి అనుగుణంగా ఆర్డర్ చేసే నిర్దేశిత ప్రారంభ సామర్థ్యంతో ఖాళీ క్యూ.
• PriorityQueue(int initialCapacity, Comparator comparator) - పేర్కొన్న కంపారిటర్ ప్రకారం దాని మూలకాలను ఆదేశించే నిర్దేశిత ప్రారంభ సామర్థ్యంతో ఖాళీ క్యూ.
• PriorityQueue(PriorityQueue c) - పేర్కొన్న ప్రాధాన్యత క్యూలో మూలకాలను కలిగి ఉన్న ఖాళీ క్యూ.
• PriorityQueue(SortedSet c) - పేర్కొన్న క్రమబద్ధీకరించబడిన సెట్‌లోని మూలకాలను కలిగి ఉన్న ఖాళీ క్యూ.

జావాలో ప్రాధాన్యత క్యూ క్రింది విధంగా ప్రకటించబడింది:

public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable

ప్రాధాన్యత క్యూను సృష్టిస్తోంది

పూర్ణాంకాల యొక్క ప్రాధాన్యత క్యూని క్రియేట్ చేద్దాం. ప్రాధాన్యత క్యూ అమలు, జావా కోడ్:

PriorityQueue<Integer> numbers = new PriorityQueue<>();

మేము వాదనలు లేకుండా ప్రాధాన్యత క్యూను సృష్టించాము. ఈ సందర్భంలో, ప్రాధాన్యత క్యూ యొక్క తల క్యూ యొక్క కనిష్ట సంఖ్య. మీరు తలని తీసివేస్తే, తదుపరి చిన్న మూలకం ఈ స్థానంలో ఉంటుంది. కాబట్టి మీరు ఆరోహణ క్రమంలో క్యూ నుండి మూలకాలను తీసివేయవచ్చు. అవసరమైతే మీరు కంపారిటర్ ఇంటర్‌ఫేస్‌ని ఉపయోగించి ఆర్డర్ చేసే సూత్రాన్ని మార్చవచ్చు.

జావా ప్రాధాన్యత క్యూ పద్ధతులు

PriorityQueue జావా క్లాస్ ఎలిమెంట్‌లను జోడించడానికి, తీసివేయడానికి మరియు తనిఖీ చేయడానికి ముఖ్యమైన పద్ధతులను కలిగి ఉంది.

ప్రాధాన్యత వరుసలో మూలకాలను చొప్పించండి

• boolean add(object) పేర్కొన్న మూలకాన్ని ప్రాధాన్యత క్యూలో చేర్చుతుంది. విజయం విషయంలో నిజం తిరిగి వస్తుంది. క్యూ నిండినట్లయితే, పద్ధతి మినహాయింపును అందిస్తుంది.
• boolean offer(object) ఈ ప్రాధాన్యత క్యూలో పేర్కొన్న మూలకాన్ని ఇన్‌సర్ట్ చేస్తుంది. క్యూ నిండినట్లయితే, పద్ధతి తప్పుగా చూపబడుతుంది.

మీరు జోడించే రెండు కార్యకలాపాలను ఉపయోగించవచ్చు, మెజారిటీ కేసులకు తేడాలు లేవు. ప్రాధాన్య క్యూలో ఎలిమెంట్లను జోడించడం మరియు ప్రారంభించడం యొక్క చిన్న ఉదాహరణ ఇక్కడ ఉంది.

import java.util.PriorityQueue;
import java.util.Queue;
public class Priority2 {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue1 = new PriorityQueue<>();
        for (int i = 5; i > 0; i--) {
            priorityQueue1.add(i);
        }
        System.out.println(priorityQueue1);
    priorityQueue1.offer(0);
        System.out.println(priorityQueue1);
    }
}

అవుట్‌పుట్:

[1, 2, 4, 5, 3]
[0, 2, 1, 5, 3, 4]

మూలకాల క్రమం విచిత్రంగా ఉంది, మేము దానిని తరువాత వివరిస్తాము.

ప్రాధాన్యత క్యూ నుండి మూలకాలను తిరిగి పొందడం మరియు తీసివేయడం

• boolean remove(object) ఈ క్యూ నుండి పేర్కొన్న మూలకం యొక్క ఒక ఉదాహరణను తొలగిస్తుంది, అది ఉన్నట్లయితే.
• ఆబ్జెక్ట్ పోల్() ఈ క్యూ యొక్క హెడ్‌ను తిరిగి పొందుతుంది మరియు తీసివేస్తుంది. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.
• void clear() ప్రాధాన్యత క్యూ నుండి అన్ని మూలకాలను తొలగిస్తుంది.
• ఆబ్జెక్ట్ ఎలిమెంట్() ఈ క్యూ యొక్క హెడ్‌ని తీసివేయకుండానే తిరిగి పొందుతుంది. క్యూ ఖాళీగా ఉంటే NoSuchElementExceptionని విసురుతుంది .
• ఆబ్జెక్ట్ పీక్() క్యూ యొక్క హెడ్‌ని తీసివేయకుండా తిరిగి పొందుతుంది. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.

import java.util.PriorityQueue;
import java.util.Queue;
 
public class Priority2 {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        //put 5 elements to the queue using add
        for (int i = 5; i > 0; i--) {
            priorityQueue.add(i);
        }
        System.out.println("the head of the queue = " + priorityQueue.peek());
        //removing element by element from the queue using poll and print it out
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
        //put 5 new elements into the empty queue using offer
        for (int i = 10; i > 5; i--) {
            priorityQueue.offer(i);
        }
        System.out.println("now the head of the queue = " + priorityQueue.peek());
        System.out.println("the queue before removing 9:");
        System.out.println(priorityQueue);
        priorityQueue.remove(9);
        System.out.println("the queue after removing 9:");
        System.out.println(priorityQueue);
        //removing all the elements from the queue
        priorityQueue.clear();
        System.out.println(priorityQueue);
        //trying to print out the head of the empty Queue using peek - we'll get null
        System.out.println(priorityQueue.peek());
        //trying to print out the head of the empty Queue using element - we'll get the exception
        System.out.println(priorityQueue.element());
    }
}

అవుట్‌పుట్:

the head of the queue = 1
1
2
3
4
5
now the head of the queue = 6
the queue before removing 9:
[6, 7, 9, 10, 8]
the queue after removing 9:
[6, 7, 8, 10]
[]
null
Exception in thread "main" java.util.NoSuchElementException
  at java.base/java.util.AbstractQueue.element(AbstractQueue.java:136)
  at Priority2.main(Priority2.java:32)

మీరు చూడగలిగినట్లుగా, ఎలిమెంట్() పద్ధతిని ఉపయోగించి ఖాళీ క్యూ యొక్క హెడ్‌ని ప్రింట్ చేయడానికి ప్రయత్నించడం NoSuchElementexception కు దారి తీస్తుంది .

ప్రాధాన్యత క్యూ కంపారేటర్

• కంపారిటర్ కంపారిటర్() క్యూలోని ఎలిమెంట్‌లను ఆర్డర్ చేయడానికి ఉపయోగించిన కంపారిటర్‌ని అందిస్తుంది. క్యూ దాని మూలకాల యొక్క సహజ క్రమం ప్రకారం క్రమబద్ధీకరించబడితే, అది శూన్యంగా చూపబడుతుంది.

జావా ప్రాధాన్యత క్యూ, కంపారిటర్‌తో ఉదాహరణ

మేము పైన ఉన్న కోడ్ ఉదాహరణలలో సహజమైన (ఆరోహణ) క్రమాన్ని ఉపయోగించాము, కానీ కొన్నిసార్లు మనం దానిని మార్చాలి. ఇక్కడ జావా ప్రాధాన్యత క్యూ ఉదాహరణ ఉంది, ఇక్కడ మేము కంపారిటర్ ఇంటర్‌ఫేస్‌ను అమలు చేసే మా స్వంత అంతర్గత కంపారిటర్ క్లాస్‌ని సృష్టించాము. మా కంపారిటర్ ఎలిమెంట్‌లను పెద్దవి నుండి చిన్నవి వరకు క్రమబద్ధీకరిస్తారు.

import java.util.PriorityQueue;
import java.util.Comparator;
 
class Priority3 {
    public static void main(String[] args) {
        // Creating a priority queue with myComparator
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new MyComparator());
        for (int i = 5; i > 0; i--) {
            priorityQueue.add(i);
        }
        System.out.println("the head of Queue = " + priorityQueue.peek());
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}
 
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer number1, Integer number2) {
        int value = number1.compareTo(number2);
        //sorting elements from maximal to minimal
        if (value > 0) {
            return -1;
        } else if (value < 0) {
            return 1;
        } else {
            return 0;
        }
    }
}

అవుట్‌పుట్:

the head of Queue = 5
5
4
3
2
1

క్యూ యొక్క హెడ్ ఇప్పుడు కనిష్టమైనది కాదు, కానీ గరిష్ట మూలకం, మరియు ఆర్డర్ రివర్స్‌కు మార్చబడింది.

ఇటరేటర్‌ని ఉపయోగించి ప్రయారిటీక్యూపై మళ్లించడం

ProrityQueue అనేది కలెక్షన్ ఫ్రేమ్‌వర్క్‌లో ఒక భాగం మరియు Iterable<> ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది. ప్రాధాన్య క్యూలోని మూలకాలపై మళ్ళించడానికి మీరు ఇటరేటర్() పద్ధతిని ఉపయోగించవచ్చు . ఇక్కడ ఒక ఉదాహరణ:

import java.util.PriorityQueue;
import java.util.Iterator;
import java.util.Queue;
 
class Priority4 {
   public static void main(String[] args) {
       // Creating a priority queue
       Queue<Integer> priorityQueue = new PriorityQueue<>();
       //put 5 elements to the queue using add
       for (int i = 5; i > 0; i--) {
           priorityQueue.add(i);
       }
       //Iterating via iterator() method
       Iterator<Integer> iterator = priorityQueue.iterator();
       while (iterate.hasNext()) {
           System.out.print(iterator.next() + " ");
       }
   }
}

అవుట్‌పుట్:

1 2 4 5 3 

మరిన్ని ప్రాధాన్యత క్యూ పద్ధతులు

• క్యూలో o మూలకం ఉంటే boolean కలిగి (Object o) నిజాన్ని అందిస్తుంది.
• int size() ఈ క్యూలోని మూలకాల సంఖ్యను అందిస్తుంది.
• ఆబ్జెక్ట్[] toArray() ఈ క్యూలోని అన్ని ఎలిమెంట్‌లను కలిగి ఉన్న శ్రేణిని అందిస్తుంది.

ఇక్కడ ఒక ఉదాహరణ:

import java.util.PriorityQueue;
import java.util.Queue;
 
public class Priority5 {
   public static void main(String[] args) {
       Queue<Integer> priorityQueue = new PriorityQueue<>();
       for (int i = 5; i > 0; i--) {
           priorityQueue.offer(i);
       }
 
       System.out.println("our queue: " + priorityQueue);
 
       System.out.println("Does our queue contain 8?  " + priorityQueue.contains(8));
       System.out.println("Does queue contain 5?  " + priorityQueue.contains(5));
 
       System.out.println("The quantity of queue elements: " + priorityQueue.size());
       Object[] myArray = priorityQueue.toArray();
       System.out.println("print out our array:");
       for (Object name : myArray) {
           System.out.println(name);
       }
   }
}

అవుట్‌పుట్:

our queue: [1, 2, 4, 5, 3]
Does our queue contain 8?  false
Does our queue contain 5?  true
The quantity of queue elements: 5
print out our array:
1
2
4
5
3

PriorityQueue Java 8 నిర్వచనం

మీరు priorityqueue java 8 డాక్యుమెంటేషన్‌ను తెరిస్తే, మీరు అక్కడ తదుపరి నిర్వచనాన్ని కనుగొంటారు: ప్రాధాన్యతా కుప్ప ఆధారంగా అపరిమిత ప్రాధాన్యత క్యూ. ప్రాధాన్య క్యూలోని మూలకాలు వాటి సహజ క్రమానికి అనుగుణంగా లేదా క్యూ నిర్మాణ సమయంలో అందించబడిన కంపారిటర్ ద్వారా ఏ కన్స్ట్రక్టర్ ఉపయోగించబడుతుందో బట్టి ఆర్డర్ చేయబడతాయి. ప్రాధాన్యత క్యూ శూన్య మూలకాలను అనుమతించదు. సహజమైన ఆర్డర్‌పై ఆధారపడిన ప్రాధాన్యత క్యూ కూడా పోల్చలేని వస్తువులను చొప్పించడాన్ని అనుమతించదు (అలా చేయడం వలన ClassCastExceptionకు దారి తీయవచ్చు). ఇక్కడ కుప్ప అనేది చాలా ముఖ్యమైన పదం. ఇది ప్రాధాన్య క్యూ ఎలిమెంట్స్ ఆర్డరింగ్ యొక్క లక్షణాలను వివరిస్తుంది.

PriorityQueue పని సూత్రం: బైనరీ హీప్

ఒక ఉదాహరణతో ప్రారంభిద్దాం. క్యూ ఇంటర్‌ఫేస్‌ను అమలు చేసే రెండు ఆబ్జెక్ట్‌లను క్రియేట్ చేద్దాం. వాటిలో ఒకటి లింక్డ్‌లిస్ట్, రెండవది - ప్రయారిటీ క్యూ. రెండూ పూర్ణాంకం (1,2,3,4 మరియు 5) యొక్క 5 మూలకాలను కలిగి ఉన్నాయి మరియు మేము మూలకాలను మా క్యూలలో పెద్దది నుండి చిన్నది వరకు ఉంచడం ప్రారంభిస్తాము. కాబట్టి, మొదటిది 5 వస్తుంది, ఆపై 4, 3, 2 మరియు చివరిది 1 అవుతుంది. ఆపై ఆర్డర్‌ని తనిఖీ చేయడానికి రెండు జాబితాలను ప్రింట్ చేయండి.

   Queue<Integer> queueL = new LinkedList<>();
       for (int i = 5; i > 0; i--) {
           queueL.add(i);
       }
       System.out.println("LinkedList Queue (FIFO): " + queueL);
       Queue<Integer> priorityQueue = new PriorityQueue<>();
 
       for (int i = 5; i > 0; i--) {
       priorityQueue.offer(i);
       }
       System.out.println("PriorityQueue: " + priorityQueue)

ఈ కోడ్ పని ఫలితం క్రిందిది:

LinkedList Queue (FIFO): [5, 4, 3, 2, 1]
PriorityQueue: [1, 2, 4, 5, 3]

బాగా, లింక్డ్‌లిస్ట్ ఆర్డర్ ఊహించదగినది మరియు అర్థమయ్యేలా ఉంది. ఇది FIFO సూత్రం ప్రకారం ఆర్డర్ చేయబడింది. మేము 5 తో ప్రారంభించాము, కాబట్టి ఈ మూలకం లైన్‌లో మొదటిది, ఆపై 4 మరియు మొదలైనవి. ప్రాధాన్యత క్యూ ఆర్డర్ గురించి మనం ఏమి చెప్పగలం? ప్రాధాన్య క్యూలోని మూలకాలు వాటి సహజ క్రమం ప్రకారం లేదా క్యూ నిర్మాణ సమయంలో అందించిన కంపారిటర్ ద్వారా ఆర్డర్ చేయబడతాయని డాక్స్ తెలిపింది. అయితే ఈ ఆర్డర్ లీనియర్ సార్టింగ్ అర్థంలో “సహజమైనది” అనిపించడం లేదు. మేము ఆశించేది [1, 2, 3, 4, 5], కాదు [1, 2, 4, 5, 3]. తిరిగి పొందే క్రమం ఇలా ఎందుకు ఉందో అర్థం చేసుకోవడానికి, కుప్ప ఆధారంగా ఉన్న ప్రాధాన్యత క్యూని మనం గుర్తు చేసుకోవాలి. కుప్ప అంటే ఏమిటి? ఇది బైనరీ ట్రీ ఆధారంగా డేటా స్ట్రక్చర్. కుప్ప యొక్క ప్రధాన ఆస్తి: ప్రతి తల్లిదండ్రుల ప్రాధాన్యత దాని పిల్లల ప్రాధాన్యతల కంటే ఎక్కువగా ఉంటుంది. ప్రతి పేరెంట్‌కు ఇద్దరు కంటే ఎక్కువ పిల్లలు లేనట్లయితే చెట్టును పూర్తి బైనరీ అని పిలుస్తారని నేను మీకు గుర్తు చేస్తాను మరియు స్థాయిలను నింపడం పై నుండి క్రిందికి (అదే స్థాయి నుండి - ఎడమ నుండి కుడికి) వెళుతుంది. బైనరీ హీప్ దాని నుండి మూలకాలు జోడించబడిన లేదా తీసివేయబడిన ప్రతిసారీ దానినే పునర్వ్యవస్థీకరిస్తుంది. min-heap విషయంలో, అతిచిన్న మూలకం దాని చొప్పించే క్రమంతో సంబంధం లేకుండా మూలానికి వెళుతుంది. ఈ మిని-హీప్ ఆధారంగా ప్రాధాన్యత క్యూ. అంటే, సంఖ్యల క్యూ మూలకాల విషయంలో, క్యూలోని మొదటి మూలకం ఈ సంఖ్యలలో కనిష్టంగా ఉంటుంది. మీరు రూట్‌ను తొలగిస్తే, తదుపరి చిన్నది రూట్ అవుతుంది.

మన ఉదాహరణకి వెళ్దాం.

దశ 1. మేము ప్రాధాన్యత క్యూలో '5'ని ఉంచాము. ఇది రూట్ అవుతుంది. దశ 2. మేము ప్రాధాన్యత క్యూలో '4'ని జోడిస్తాము. 4 <5, కాబట్టి కొత్త మూలకం పాతదాని కంటే ఎక్కువగా ఉండాలి. 4 రూట్ అవుతుంది, 5 దాని ఎడమ బిడ్డ. ఇప్పుడు జావాలోని డేటా స్ట్రక్చర్ [4, 5] దశ 3. మేము '3'ని జోడిస్తాము. తాత్కాలికంగా అది ఒక మూలం యొక్క సరైన బిడ్డ అవుతుంది (4). అయితే, 3 <4, కాబట్టి మనం దానిని పైకి ఎత్తాలి. మార్పిడి 3 మరియు 4. ఇప్పుడు మనకు [3, 5, 4] దశ 4 వంటి నిర్మాణం ఉంది. మేము '2'ని జోడిస్తాము. ఇది 5. 2<5 యొక్క ఎడమ బిడ్డ అవుతుంది, కాబట్టి వాటిని మార్పిడి చేయండి. 2 3, 2 <3 యొక్క ఎడమ చైల్డ్ అవుతుంది, కాబట్టి మరొక మార్పిడి ప్రక్రియ. ఇప్పుడు మనకు ఒక నిర్మాణం ఉంది [2,3,4,5] దశ 5.మేము '1'ని జోడిస్తాము. ఇది 3 యొక్క కుడి బిడ్డ నుండి 2 యొక్క ఎడమ బిడ్డకు వస్తుంది, ఆపై మూలానికి వెళుతుంది. ఫలిత డేటా నిర్మాణం: [1,2,4,5,3] తొలగింపు ప్రక్రియ రూట్ నుండి ప్రారంభమవుతుంది మరియు ఇది రివర్స్ విధానాలను రేకెత్తిస్తుంది. కాబట్టి, మొదట మనకు రూట్‌గా 1 ఉంది, తర్వాత 2, 3, 4 మరియు చివరిగా 5. అందుకే రిమూవ్ ఆపరేషన్ పోల్()ని ఉపయోగిస్తాము

while (!priorityQueue.isEmpty()) {
           System.out.println(priorityQueue.poll());
       }

మేము లీనియర్ సెన్స్ అవుట్‌పుట్‌లో “క్రమబద్ధీకరించాము”:

1
2
3
4
5

కాబట్టి కొన్ని కార్యకలాపాలకు ప్రాధాన్యత క్యూ ప్రభావవంతంగా ఉంటుంది. ప్రతి మూలకాన్ని చొప్పించడానికి మరియు తొలగించడానికి O(log N) సమయం పడుతుంది మరియు మీరు O(1)లో కనిష్ట మూలకాన్ని పొందవచ్చు. పూర్తి ఉదాహరణ ఇక్కడ ఉంది:

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
 
public class PriorityQueueExample {
   public static void main(String[] args) {
 
       Queue<Integer> queueL = new LinkedList<>();
       for (int i = 5; i > 0; i--) {
           queueL.add(i);
       }
       System.out.println("Print our LinkedList Queue (FIFO): " + queueL);
       Queue<Integer> priorityQueue = new PriorityQueue<>();
 
       for (int i = 5; i > 0; i--) {
       priorityQueue.offer(i);
       }
 
       System.out.println("PriorityQueue printing (by iterating, no elements removing): " + priorityQueue);
       System.out.println("Print PriorityQueue using poll() (by retrieval): " );
       while (!priorityQueue.isEmpty()) {
           System.out.println(priorityQueue.poll());
       }
}
}
Print our LinkedList Queue (FIFO): [5, 4, 3, 2, 1]
PriorityQueue printing (by iterating, no elements removing): [1, 2, 4, 5, 3]
Print our  PriorityQueue using poll() (by retrieval): 
1
2
3
4
5

ప్రాధాన్యత క్యూలు బైనరీ హీప్స్‌పై ఆధారపడి ఉన్నాయని అర్థం చేసుకోవడం ముఖ్యం, కాబట్టి అవి ఎలిమెంట్‌లను లీనియర్ క్రమబద్ధీకరించిన క్రమంలో ఉంచవు. మూలం నుండి ఆకు వరకు ప్రతి మార్గం ఆదేశించబడింది, కానీ వేరు నుండి వేర్వేరు మార్గాలు కాదు. అంటే మీరు క్యూ యొక్క కనీస మూలకాన్ని చాలా త్వరగా పొందవచ్చు.

ప్రాధాన్యత క్యూ గురించి మీరు తెలుసుకోవలసినది. సంక్షిప్త జాబితా

• ప్రాధాన్యత వరుస NULL వస్తువులను అనుమతించదు.
• మీరు PriorityQueueలో పోల్చదగిన వస్తువులను మాత్రమే జోడించగలరు.
• ప్రాధాన్యత క్యూ నిమి కుప్పగా, ఒక రకమైన బైనరీ ట్రీగా నిర్మించబడింది. కనిష్ట మూలకం ఒక మూలం. ప్రాధాన్యత క్యూలోని వస్తువులు సహజ క్రమంలో డిఫాల్ట్‌గా ఆర్డర్ చేయబడతాయి.
• మీకు అనుకూల ఆర్డరింగ్ అవసరమైతే మీరు కంపారిటర్‌ని ఉపయోగించవచ్చు.
• PriorityQueue థ్రెడ్ సురక్షితం కాదు, కాబట్టి మీరు ఉమ్మడి వాతావరణంలో పని చేయడానికి PriorityBlockingQueueని ఉపయోగించడం మంచిది.
• PriorityQueue యాడ్ మరియు పోల్ పద్ధతుల కోసం O(log(n)) సమయాన్ని అందిస్తుంది మరియు కనిష్ట అంశాలను పొందడానికి O(1)ని అందిస్తుంది.