جاوا ترجیحی قطار: کلاسیکی قطار نہیں۔

اس آرٹیکل میں ہم ایک ترجیحی قطار، جاوا کلاس سیکھتے ہیں، جو قطار انٹرفیس کو نافذ کرتی ہے۔ ایک پروگرامر باقاعدہ قطار انٹرفیس کے بارے میں کیا جانتا ہے؟ سب سے پہلے، یہ انٹرفیس FIFO اصول یا "فرسٹ ان فرسٹ آؤٹ" پر مبنی ہے۔ یہ اس کے عام معنی میں ایک باقاعدہ قطار کی یاد دلاتا ہے۔ آپ McDrive سے کافی لینا چاہتے ہیں؟ اگر آپ کی گاڑی کھڑکی کے قریب پہلی ہے، تو آپ کو اپنی کافی اس ڈرائیور سے پہلے ملے گی جو اگلا ہے۔

قطار انٹرفیس کا اعلان

public interface Queue<E> extends Collection<E>

ترجیحی قطار کیا ہے؟

ترجیحی قطار کیا ہے؟ سب سے پہلے یہ ایک کلاس ہے جو پیچھے سے کسی عنصر کو داخل کرنے اور کسی عنصر کو سر سے ہٹانے کی صورت میں قطار انٹرفیس کو نافذ کرتی ہے۔ تاہم یہ اندر کی معمول کی قطار نہیں ہے۔ جاوا ترجیحی قطار عناصر کی ترتیب عناصر کی ترجیح پر منحصر ہے۔ سب سے زیادہ ترجیح والے عنصر کو قطار کے سر پر منتقل کیا جائے گا۔ اگر آپ سب سے اونچے درجے والے عنصر کو حذف (سروس) کرتے ہیں، تو دوسرا اس کی کافی لینے کے لیے سر پر جاتا ہے۔ ترجیح کا تعین کیسے ہوتا ہے؟ دستاویزات کے مطابق، ترجیحی قطار کے عناصر کو ان کی فطری ترتیب کے مطابق ترتیب دیا جاتا ہے، یا قطار کی تعمیر کے وقت فراہم کردہ موازنہ کنندہ کے ذریعہ، اس پر منحصر ہوتا ہے کہ کنسٹرکٹر استعمال کیا جاتا ہے۔ ترجیحی کم ہیپ کی بنیاد پر ترجیحی قطار۔ اس کا مطلب ہے، نمبروں کی قطار کے عناصر کی صورت میں، قطار کا پہلا عنصر ان نمبروں کا کم سے کم ہوگا۔ اکثر اس تعریف کو پڑھنے کے بعد دوکھیباز طلباء یہ سوچنے لگتے ہیں کہ ترجیحی قطار کو لکیری معنوں میں ترتیب دیا گیا ہے۔ یعنی، اگر، کہتے ہیں، ہم ایک قطار استعمال کرتے ہیں جس کے عناصر قدرتی اعداد ہیں، تو پہلا عنصر سب سے چھوٹا اور آخری - سب سے بڑا ہوگا۔ یہ مکمل طور پر درست نہیں ہے۔ یہ سمجھنے کے لیے کہ ترجیحی قطار دراصل کیسے کام کرتی ہے اور یہ کیا دیتی ہے، آپ کو یہ معلوم کرنا ہوگا کہ ہیپ کیسے کام کرتا ہے۔ ہم تھوڑی دیر بعد ایک مثال کا استعمال کرتے ہوئے ترجیحی قطار کی اندرونی ساخت پر غور کرتے ہیں۔ اب آئیے اس کی ظاہری صفات پر غور کریں۔

ترجیحی قطار کلاس کنسٹرکٹر اور اعلان

PriorityQueue کلاس جاوا میں ترجیحی قطار بنانے کے 6 مختلف طریقے فراہم کرتی ہے۔

• PriorityQueue() - پہلے سے طے شدہ ابتدائی صلاحیت (11) کے ساتھ خالی قطار جو اپنے عناصر کو ان کی فطری ترتیب کے مطابق ترتیب دیتی ہے۔
• PriorityQueue(مجموعہ 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<>();

ہم نے دلائل کے بغیر ترجیحی قطار بنائی ہے۔ اس صورت میں، ترجیحی قطار کا سربراہ قطار کی کم سے کم تعداد ہے۔ اگر آپ سر کو ہٹاتے ہیں، تو اگلا سب سے چھوٹا عنصر اس جگہ کو لے جائے گا. لہذا آپ قطار سے عناصر کو صعودی ترتیب میں ہٹا سکتے ہیں۔ اگر ضروری ہو تو آپ Comparator انٹرفیس کا استعمال کرتے ہوئے آرڈر کرنے کے اصول کو تبدیل کر سکتے ہیں۔

جاوا ترجیحی قطار کے طریقے

PriorityQueue Java کلاس میں عناصر کو شامل کرنے، ہٹانے اور چیک کرنے کے اہم طریقے ہیں۔

ترجیحی قطار میں عناصر داخل کریں۔

• بولین ایڈ (آبجیکٹ) مخصوص عنصر کو ترجیحی قطار میں داخل کرتا ہے۔ کامیابی کی صورت میں درست لوٹتا ہے۔ اگر قطار بھری ہوئی ہے، تو طریقہ مستثنیٰ ہے۔
• بولین پیشکش (آبجیکٹ) مخصوص عنصر کو اس ترجیحی قطار میں داخل کرتا ہے۔ اگر قطار بھری ہوئی ہے، تو طریقہ غلط لوٹاتا ہے۔

آپ دونوں اضافی کارروائیوں کا استعمال کر سکتے ہیں، اکثریت کے معاملات میں کوئی فرق نہیں ہے۔ یہاں شروع کرنے اور عناصر کو ترجیحی قطار میں شامل کرنے کی ایک چھوٹی سی مثال ہے۔

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 پھینک دیتا ہے ۔
• آبجیکٹ 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 کی طرف جاتا ہے ۔

ترجیحی قطار کا موازنہ کرنے والا

• Comparator comparator() وہ comparator واپس کرتا ہے جو قطار میں موجود عناصر کو آرڈر کرنے کے لیے استعمال کرتا تھا۔ اگر قطار کو اس کے عناصر کی قدرتی ترتیب کے مطابق ترتیب دیا گیا ہو تو null لوٹاتا ہے۔

جاوا ترجیحی قطار، موازنہ کے ساتھ مثال

ہم نے اوپر والے کوڈ کی مثالوں میں قدرتی (صعودی) ترتیب کا استعمال کیا، لیکن بعض اوقات ہمیں اسے تبدیل کرنا چاہیے۔ یہ جاوا کی ترجیحی قطار کی مثال ہے، جہاں ہم اپنی داخلی کمپیریٹر کلاس بناتے ہیں جو 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

ترجیحی قطار جاوا 8 کی تعریف

اگر آپ priorityqueue java 8 دستاویزات کو کھولتے ہیں، تو آپ کو وہاں اگلی تعریف ملے گی: ترجیحی ہیپ پر مبنی ایک غیر محدود ترجیحی قطار۔ ترجیحی قطار کے عناصر کو ان کی فطری ترتیب کے مطابق ترتیب دیا جاتا ہے، یا قطار کی تعمیر کے وقت فراہم کردہ موازنہ کنندہ کے ذریعہ، اس پر منحصر ہے کہ کنسٹرکٹر استعمال کیا جاتا ہے۔ ترجیحی قطار کالعدم عناصر کی اجازت نہیں دیتی۔ فطری ترتیب پر انحصار کرنے والی ترجیحی قطار بھی غیر موازنہ آبجیکٹ کو داخل کرنے کی اجازت نہیں دیتی ہے (ایسا کرنے سے ClassCastException ہو سکتا ہے)۔ ہیپ یہاں ایک بہت اہم لفظ ہے۔ یہ ترجیحی قطار کے عناصر کی ترتیب کی خصوصیات کی وضاحت کرتا ہے۔

ترجیحی قطار کے کام کا اصول: بائنری ہیپ

آئیے ایک مثال سے شروع کرتے ہیں۔ آئیے قطار انٹرفیس کو لاگو کرتے ہوئے دو آبجیکٹ بنائیں۔ ان میں سے ایک LinkedList، دوسری - PriorityQueue۔ ان دونوں میں انٹیجر کے 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 جاتا ہے اور اسی طرح. ہم ترجیحی قطار کے آرڈر کے بارے میں کیا بتا سکتے ہیں؟ دستاویزات نے کہا کہ ترجیحی قطار کے عناصر کو ان کی فطری ترتیب کے مطابق ترتیب دیا جاتا ہے، یا قطار کی تعمیر کے وقت فراہم کردہ موازنہ کار کے ذریعے۔ تاہم یہ ترتیب لکیری چھانٹی کے معنی میں "قدرتی" نہیں لگتی ہے۔ ہم توقع کریں گے [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 میں صرف تقابلی اشیاء شامل کر سکتے ہیں۔
• ترجیحی قطار ایک منٹ کے ڈھیر کے طور پر بنائی جاتی ہے، ایک قسم کا بائنری درخت۔ کم سے کم عنصر ایک جڑ ہے۔ ترجیحی قطار کی اشیاء کو قدرتی ترتیب میں بطور ڈیفالٹ ترتیب دیا جاتا ہے۔
• اگر آپ کو حسب ضرورت آرڈرنگ کی ضرورت ہو تو آپ Comparator استعمال کر سکتے ہیں۔
• PriorityQueue تھریڈ محفوظ نہیں ہے، اس لیے آپ ایک ساتھ ماحول میں کام کرنے کے لیے PriorityBlockingQueue کو بہتر طور پر استعمال کریں۔
• PriorityQueue شامل کرنے اور پول کرنے کے طریقوں کے لیے O(log(n)) وقت اور O(1) کو کم سے کم عناصر حاصل کرنے کے لیے فراہم کرتا ہے۔