Java Priority Queue: نه ڪلاسيڪل قطار

هن آرٽيڪل ۾ اسان هڪ ترجيحي قطار سکندا آهيون، جاوا ڪلاس، جيڪو قطار انٽرفيس کي لاڳو ڪري ٿو. هڪ پروگرامر کي باقاعده قطار انٽرفيس جي ڪهڙي خبر آهي؟ سڀ کان پهريان، هي انٽرفيس FIFO اصول تي ٻڌل آهي يا "پهرين پهرين ۾". اهو ان جي عام معني ۾ هڪ باقاعده قطار ياد ڏياريندو آهي. توهان McDrive کان ڪافي حاصل ڪرڻ چاهيو ٿا؟ جيڪڏھن توھان جي ڪار ونڊو جي ويجھو پھرين آھي، توھان ڊرائيور کان اڳ توھان جي ڪافي حاصل ڪندا جيڪو اڳيان آھي.

قطار انٽرفيس جو اعلان

public interface Queue<E> extends Collection<E>

ترجيحي قطار ڇا آھي

ترجيحي قطار ڇا آھي؟ سڀ کان پهريان اهو هڪ طبقو آهي جيڪو قطار جي انٽرفيس کي لاڳو ڪري ٿو جڏهن ڪنهن عنصر کي پوئتي کان داخل ڪرڻ ۽ هڪ عنصر کي سر مان هٽائڻ جي صورت ۾. تنهن هوندي به اهو هڪ معمولي قطار اندر نه آهي. جاوا جي ترجيحي قطار عناصر جو حڪم عناصر جي ترجيح تي منحصر آھي. سڀ کان وڌيڪ ترجيح سان عنصر کي قطار جي سر ڏانھن منتقل ڪيو ويندو. جيڪڏهن توهان سڀ کان وڌيڪ درجه بندي واري عنصر کي حذف (خدمت) ڪريو ٿا، ته ٻيو هڪ ان جي ڪافي حاصل ڪرڻ لاء سر ڏانهن وڃي ٿو. ترجيح ڪيئن طئي ڪئي وئي آهي؟ دستاويزن جي مطابق، ترجيحي قطار جي عناصر کي انهن جي قدرتي ترتيب جي مطابق ترتيب ڏنو ويو آهي، يا قطار جي تعمير جي وقت تي مهيا ڪيل هڪ موازنہ ڪندڙ طرفان، ان تي منحصر ڪيو ويو آهي جنهن تي تعمير ڪندڙ استعمال ڪيو ويندو آهي. هڪ ترجيحي قطار ترجيحي منٽ جي ڍير جي بنياد تي. ان جو مطلب آهي، انگن جي قطار عناصر جي صورت ۾، قطار جو پهريون عنصر انهن نمبرن جو گهٽ ۾ گهٽ هوندو. گهڻو ڪري هن تعريف کي پڙهڻ کان پوءِ روڪي شاگرد سوچڻ شروع ڪن ٿا ته ترجيحي قطار هڪ لڪير ۾ ترتيب ڏنل آهي. اهو آهي، جيڪڏهن، چئو، اسان هڪ قطار استعمال ڪندا آهيون جنهن جا عنصر قدرتي انگ آهن، پوء پهريون عنصر ننڍو ٿيندو، ۽ آخري - سڀ کان وڏو. اهو بلڪل صحيح ناهي. سمجھڻ لاءِ ته ترجيحي قطار اصل ۾ ڪيئن ڪم ڪري ٿي ۽ اھو ڇا ڏئي ٿي، توھان کي اھو ڄاڻڻ جي ضرورت آھي ته ھيپ ڪيئن ڪم ڪري ٿي. اسان ڪجهه دير بعد مثال استعمال ڪندي ترجيحي قطار جي اندروني جوڙجڪ تي غور ڪندا آهيون. هاڻي اچو ته ان جي خارجي خاصيتن تي رهون.

ترجيحي قطار ڪلاس تعمير ڪندڙ ۽ اعلان

PriorityQueue class مهيا ڪري ٿي 6 مختلف طريقا جاوا ۾ ترجيحي قطار ٺاھڻ لاءِ.

• PriorityQueue() - ڊفالٽ شروعاتي ظرفيت سان خالي قطار (11) جيڪو پنھنجي عناصر کي پنھنجي قدرتي ترتيب جي مطابق ترتيب ڏئي ٿو.
• PriorityQueue(collection c) - خالي قطار جنهن ۾ مخصوص ڪليڪشن ۾ عناصر شامل آهن.
• 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<>();

اسان بغير دليلن جي هڪ ترجيحي قطار ٺاهي آهي. انهي صورت ۾، ترجيحي قطار جو سر قطار جو گھٽ ۾ گھٽ تعداد آھي. جيڪڏهن توهان سر کي هٽائي ڇڏيو، ايندڙ ننڍڙو عنصر هن جڳهه کي وٺي ويندي. تنهن ڪري توهان عنصرن کي قطار مان ختم ڪري سگهو ٿا چڙهندڙ ترتيب ۾. جيڪڏھن ضروري ھجي ته توھان ڪمپريٽر انٽرفيس استعمال ڪندي ترتيب ڏيڻ جي اصول کي تبديل ڪري سگھو ٿا.

Java 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) هن قطار مان مخصوص عنصر جو هڪ مثال هٽائي ٿو، جيڪڏهن اهو موجود آهي.
• اعتراض پول () هن قطار جي سر کي ٻيهر حاصل ڪري ٿو ۽ هٽائي ٿو. واپسي null جيڪڏھن قطار خالي آھي.
• void clear() ترجيحي قطار مان سڀني عناصر کي ختم ڪري ٿو.
• اعتراض عنصر () هن قطار جي سر کي هٽائڻ کان سواء حاصل ڪري ٿو. اڇلائي ٿو NoSuchElementException جيڪڏھن قطار خالي آھي.
• Object peek() ان کي هٽائڻ کان سواءِ قطار جي سر کي ٻيهر حاصل ڪري ٿو. واپسي null جيڪڏھن قطار خالي آھي.

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)

جئين توهان ڏسي سگهو ٿا، element() طريقو استعمال ڪندي خالي قطار جي سر کي پرنٽ ڪرڻ جي ڪوشش ڪري ٿو NoSuchElementexception .

Priority Queue Comparator

• Comparator comparator() comparator واپس ڪري ٿو جيڪو قطار ۾ عناصر کي ترتيب ڏيڻ لاء استعمال ڪيو ويو. واپسي null جيڪڏھن قطار ان جي عناصر جي قدرتي ترتيب جي مطابق ترتيب ڏنل آھي.

Java priority queue، مثال سان comparator

اسان مٿي ڏنل ڪوڊ مثالن ۾ قدرتي (چڙندڙ) ترتيب استعمال ڪيو، پر ڪڏهن ڪڏهن اسان کي ان کي تبديل ڪرڻ گهرجي. هتي جاوا جي ترجيحن واري قطار جو مثال آهي، جتي اسان پنهنجو اندروني موازنہ ڪلاس ٺاهيندا آهيون جيڪو Comparator انٽرفيس کي لاڳو ڪري ٿو. اسان جو مقابلو ڪندڙ عناصر کي وڏي کان ننڍي تائين ترتيب ڏيندو.

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

قطار جو مٿو ھاڻي گھٽ ۾ گھٽ نه آھي، پر وڌ ۾ وڌ عنصر آھي، ۽ ترتيب کي تبديل ڪيو ويو بدلجي ويو.

Iterator استعمال ڪندي PriorityQueue مٿان ٻيهر ڪرڻ

ProrityQueue ڪليڪشن فريم ورڪ جو حصو آهي ۽ Iterable<> انٽرفيس کي لاڳو ڪري ٿو. ترجيحي قطار جي عناصرن کي ٻيهر ڏيڻ لاء توھان استعمال ڪري سگھو ٿا iterator() طريقو. هتي هڪ مثال آهي:

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 

وڌيڪ ترجيحي قطار جا طريقا

• boolean contains(Object o) صحيح موٽائي ٿو جيڪڏهن قطار ۾ o عنصر شامل آهي.
• int size() هن قطار ۾ عناصر جو تعداد واپس ڏئي ٿو.
• Object[] 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 ڊاڪيومينٽيشن کوليو ٿا، توهان کي اتي ملندو ايندڙ وصف: هڪ بيحد ترجيح واري قطار ترجيحي هيپ جي بنياد تي. ترجيحي قطار جا عنصر انھن جي قدرتي ترتيب جي مطابق ترتيب ڏنل آھن، يا قطار جي تعمير وقت تي مهيا ڪيل ھڪڙي مقابلي ڪندڙ طرفان، ان تي منحصر آھي جنھن ٺاھيندڙ استعمال ڪيو ويو آھي. هڪ ترجيحي قطار null عناصر جي اجازت نٿو ڏئي. هڪ ترجيحي قطار جيڪا قدرتي ترتيب تي ڀاڙيندي آهي اها پڻ اجازت نه ڏيندي آهي غير موازن شين جي داخل ٿيڻ جي (انهي ڪرڻ سان نتيجو ٿي سگهي ٿو ClassCastException). هيپ هتي هڪ تمام اهم لفظ آهي. اهو وضاحت ڪري ٿو ترجيحن جي قطار عناصر جي آرڊر جي ملڪيت.

PriorityQueue ڪم جو اصول: بائنري هيپ

اچو ته هڪ مثال سان شروع ڪريون. اچو ته قطار انٽرفيس کي لاڳو ڪندي ٻه شيون ٺاهيون. انهن مان هڪ LinkedList، ٻيو - PriorityQueue. انهن ٻنهي ۾ Integer جا 5 عنصر آهن (1,2,3,4 ۽ 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 وڃي ٿو ۽ ائين ئي. اسان ترجيحي قطار جي ترتيب بابت ڇا ٿا چئون؟ Docs چيو آهي ته ترجيحي قطار جا عنصر انهن جي قدرتي ترتيب جي مطابق ترتيب ڏنل آهن، يا قطار جي تعمير جي وقت تي مهيا ڪيل هڪ موازنہ ڪندڙ طرفان. تنهن هوندي به هي نظم ”قدرتي“ معنيٰ ۾ لڪير جي ترتيب سان نٿو لڳي. اسان بجاءِ اميد رکون ٿا [1، 2، 3، 4، 5]، نه [1، 2، 4، 5، 3]. سمجھڻ لاءِ ته ڇو حاصل ڪرڻ جو حڪم ائين ئي آھي، اسان کي ياد ڪرڻ گھرجي ته ترجيحي قطار ھڪڙي ڍير جي بنياد تي. ڍڳ ڇا آهي؟ اهو بائنري وڻ تي ٻڌل ڊيٽا جي جوڙجڪ آهي . هيپ جي مکيه ملڪيت: هر والدين جي ترجيحات ان جي ٻارن جي ترجيحن کان وڌيڪ آهي. مان توهان کي ياد ڏياريان ته هڪ وڻ کي مڪمل بائنري سڏيو ويندو آهي جيڪڏهن هر والدين کي ٻن کان وڌيڪ ٻار نه هجن، ۽ سطحن جي ڀرڻ مٿي کان هيٺ تائين وڃي ٿي (ساڳي سطح کان - کاٻي کان ساڄي تائين). بائنري هيپ پاڻ کي ٻيهر منظم ڪري ٿو هر وقت عناصر شامل ڪيا وڃن يا ان مان هٽايو وڃي. منٽ-هيپ جي صورت ۾، ننڍڙو عنصر ان جي داخل ٿيڻ جي ترتيب جي بغير روٽ ڏانهن وڃي ٿو. ترجيحي قطار ھن منٽ جي بنياد تي. ان جو مطلب آهي، انگن جي قطار عناصر جي صورت ۾، قطار جو پهريون عنصر انهن نمبرن جو گهٽ ۾ گهٽ هوندو. جيڪڏھن توھان روٽ کي ختم ڪريو، ايندڙ ننڍڙو ھڪڙو روٽ بڻجي ويندو.

اچو ته اسان جي مثال ڏانهن موٽون.

قدم 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());
       }

اسان کي حاصل ڪيو ويو آهي "ترتيب" ۾ لڪير sens جي پيداوار:

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 شين جي اجازت نٿي ڏئي.
• توھان ترجيحي قطار ۾ صرف موازنہ شيون شامل ڪري سگھو ٿا.
• ترجيحي قطار هڪ منٽ هيپ جي طور تي ٺهيل آهي، بائنري وڻ جو هڪ قسم. گھٽ ۾ گھٽ عنصر ھڪڙو روٽ آھي. ترجيحي قطار جون شيون قدرتي ترتيب ۾ ڊفالٽ ترتيب ڏنل آھن.
• توھان استعمال ڪري سگھوٿا Comparator جيڪڏھن توھان کي ڪسٽم آرڊر جي ضرورت آھي.
• PriorityQueue ٿريڊ محفوظ نه آھي، تنھنڪري توھان بھتر طور استعمال ڪريو PriorityBlockingQueue کي سمورو ماحول ۾ ڪم ڪرڻ لاءِ.
• PriorityQueue مهيا ڪري ٿي O(log(n)) وقت شامل ڪرڻ ۽ پولنگ جي طريقن ۽ O(1) کي گھٽ ۾ گھٽ عناصر حاصل ڪرڻ لاءِ.