या लेखात आपण प्राधान्य रांग, Java क्लास शिकू, जी रांग इंटरफेस लागू करते. प्रोग्रामरला नियमित रांग इंटरफेसबद्दल काय माहिती आहे? सर्व प्रथम, हा इंटरफेस FIFO तत्त्वावर किंवा "फर्स्ट इन फर्स्ट आउट" वर आधारित आहे. हे त्याच्या सामान्य अर्थाने नियमित रांगेची आठवण करून देते. तुम्हाला McDrive वरून कॉफी घ्यायची आहे का? जर तुमची कार खिडकीजवळ पहिली असेल, तर तुम्हाला तुमची कॉफी पुढच्या ड्रायव्हरच्या आधी मिळेल.
रांग इंटरफेस घोषणा
public interface Queue<E> extends Collection<E>
प्राधान्य रांग म्हणजे काय
प्राधान्य रांग म्हणजे काय? सर्व प्रथम, हा एक वर्ग आहे जो मागच्या बाजूने घटक घालण्याच्या आणि डोक्यातून घटक काढून टाकण्याच्या बाबतीत रांग इंटरफेसची अंमलबजावणी करतो. मात्र आतमध्ये ही नेहमीची रांग नाही. Java अग्रक्रम रांगेतील घटकांचा क्रम घटकांच्या अग्रक्रमावर अवलंबून असतो. सर्वोच्च प्राधान्य असलेला घटक रांगेच्या शीर्षस्थानी हलविला जाईल. तुम्ही सर्वोच्च रँक असलेला घटक हटवल्यास (सर्व्ह) केल्यास, दुसरा त्याची कॉफी घेण्यासाठी डोक्यावर जाईल. प्राधान्य कसे ठरवले जाते? दस्तऐवजीकरणानुसार, प्राधान्य रांगेतील घटक त्यांच्या नैसर्गिक क्रमानुसार किंवा रांगेच्या बांधकामाच्या वेळी प्रदान केलेल्या तुलनाकर्त्याद्वारे, कोणता कन्स्ट्रक्टर वापरला जातो यावर अवलंबून असतो. प्राधान्य मिन हीपवर आधारित अग्रक्रम रांग. याचा अर्थ, संख्या रांगेतील घटकांच्या बाबतीत, रांगेचा पहिला घटक या संख्यांपैकी किमान असेल. बर्‍याचदा ही व्याख्या वाचल्यानंतर धूर्त विद्यार्थी विचार करू लागतात की प्राधान्य रांग एका रेखीय अर्थाने क्रमवारी लावली जाते. म्हणजेच, जर, म्हणा, आपण एक रांग वापरतो ज्याचे घटक नैसर्गिक संख्या आहेत, तर पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा असेल. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया. मग पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया. मग पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया.
प्राधान्य रांग वर्ग रचनाकार आणि घोषणा
PriorityQueue क्लास Java मध्ये प्रायॉरिटी रांग तयार करण्याचे 6 वेगवेगळे मार्ग प्रदान करते.
PriorityQueue() - डिफॉल्ट प्रारंभिक क्षमता (11) असलेली रिकामी रांग जी त्याच्या घटकांना त्यांच्या नैसर्गिक क्रमानुसार ऑर्डर करते.
PriorityQueue(C Collection c) - निर्दिष्ट कलेक्शनमधील घटक असलेली रिकामी रांग.
PriorityQueue(int initialCapacity) - निर्दिष्ट प्रारंभिक क्षमतेसह रिकामी रांग जी त्याच्या घटकांना त्यांच्या नैसर्गिक क्रमानुसार ऑर्डर करते.
PriorityQueue(int initialCapacity, Comparator comparator) - विनिर्दिष्ट प्रारंभिक क्षमतेसह रिकामी रांग जी निर्दिष्ट तौलनिकानुसार त्याचे घटक ऑर्डर करते.
PriorityQueue(PriorityQueue c) - रिकामी रांग ज्यामध्ये निर्दिष्ट प्राधान्य रांगेतील घटक असतात.
PriorityQueue(SortedSet c) - रिकामी रांग ज्यामध्ये नमूद केलेल्या क्रमवारीतील घटक असतात.
Java मधील प्राधान्य रांग पुढील मार्गाने घोषित केली आहे:
public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable
प्राधान्यक्रम तयार करत आहे
पूर्णांकांची अग्रक्रम रांग तयार करू. प्राधान्य रांगेची अंमलबजावणी, जावा कोड:
PriorityQueue<Integer> numbers = new PriorityQueue<>();
आम्ही युक्तिवाद न करता प्राधान्यक्रम तयार केला आहे. या प्रकरणात, प्राधान्य रांगेचे प्रमुख म्हणजे रांगेची किमान संख्या. आपण डोके काढून टाकल्यास, पुढील सर्वात लहान घटक हे स्थान घेईल. त्यामुळे तुम्ही रांगेतील घटक चढत्या क्रमाने काढू शकता. आवश्यक असल्यास, तुम्ही कम्पॅरेटर इंटरफेस वापरून ऑर्डर करण्याचे तत्त्व बदलू शकता.
Java PriorityQueue पद्धती
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]
घटकांचा क्रम विचित्र वाटतो, आम्ही नंतर स्पष्ट करू.
प्राधान्य रांगेतून घटक पुनर्प्राप्त करणे आणि काढणे
बुलियन रिमूव्ह(ऑब्जेक्ट) या रांगेतून निर्दिष्ट घटकाचा एकच प्रसंग काढून टाकतो, जर तो उपस्थित असेल.
ऑब्जेक्ट पोल() या रांगेचे प्रमुख पुनर्प्राप्त करते आणि काढून टाकते. रांग रिकामी असल्यास शून्य परत करते.
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)
तुम्ही बघू शकता, element() पद्धतीचा वापर करून रिकाम्या रांगेचे हेड मुद्रित करण्याचा प्रयत्न केल्याने NoSuchElementexception होतो .
प्राधान्य रांग तुलनाकर्ता
Comparator comparator() रांगेतील घटक ऑर्डर करण्यासाठी वापरलेला comparator परत करतो. रांग त्याच्या घटकांच्या नैसर्गिक क्रमानुसार क्रमवारी लावल्यास शून्य मिळवते.
Java प्राधान्य रांग, तुलनाकर्ता सह उदाहरण
आम्ही वरील कोड उदाहरणांमध्ये नैसर्गिक (चढत्या) क्रमाचा वापर केला आहे, परंतु काहीवेळा आम्ही तो बदलला पाहिजे. येथे जावा प्राधान्य रांगेचे उदाहरण आहे, जेथे आम्ही आमचा स्वतःचा अंतर्गत तुलनाकर्ता वर्ग तयार करतो जो तुलनाकर्ता इंटरफेस लागू करतो. आमचा तुलनाकर्ता सर्वात मोठ्या ते सर्वात लहान घटकांची क्रमवारी लावेल.
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
आता रांगेचे शीर्ष किमान नाही, परंतु कमाल घटक आहे आणि क्रम उलट केला गेला आहे.
इटरेटर वापरून 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
अधिक प्राधान्य रांग पद्धती
रांगेत o घटक असल्यास boolean contains(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 कामाचे तत्त्व: बायनरी हीप
चला एका उदाहरणाने सुरुवात करूया. रांग इंटरफेसची अंमलबजावणी करणारे दोन ऑब्जेक्ट्स तयार करू. त्यापैकी एक 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)
बरं, लिंक्डलिस्ट ऑर्डर अंदाजे आणि समजण्यायोग्य आहे. हे फिफो तत्त्वानुसार ऑर्डर केले जाते. आम्ही 5 ने सुरुवात केली, म्हणून हा घटक ओळीत सर्वात पहिला आहे, नंतर 4 जातो आणि असेच. आम्ही प्राधान्य रांगेच्या ऑर्डरबद्दल काय सांगू शकतो? डॉक्सने म्हटले आहे की प्राधान्य रांगेतील घटक त्यांच्या नैसर्गिक क्रमानुसार किंवा रांगेच्या बांधकामाच्या वेळी प्रदान केलेल्या तुलनाकर्त्याद्वारे ऑर्डर केले जातात. तथापि हा क्रम रेखीय वर्गीकरणाच्या अर्थाने "नैसर्गिक" असल्याचे दिसत नाही. आम्ही त्याऐवजी [१, २, ३, ४, ५] अपेक्षा करू, [१, २, ४, ५, ३] नाही. पुनर्प्राप्त करण्याचा क्रम असा का आहे हे समजून घेण्यासाठी, आपण हीपवर आधारित ती प्राधान्य रांग लक्षात ठेवली पाहिजे. ढीग काय आहे? ही बायनरी ट्रीवर आधारित डेटा स्ट्रक्चर आहे. ढिगाऱ्याची मुख्य मालमत्ता: प्रत्येक पालकाची प्राथमिकता त्याच्या मुलांच्या प्राधान्यांपेक्षा जास्त असते. मी तुम्हाला आठवण करून देतो की जर प्रत्येक पालकाला दोनपेक्षा जास्त मुले नसतील तर झाडाला पूर्ण बायनरी म्हणतात आणि स्तर भरणे वरपासून खालपर्यंत (समान पातळीपासून - डावीकडून उजवीकडे) जाते. प्रत्येक वेळी घटक जोडले जातात किंवा काढून टाकले जातात तेव्हा बायनरी हीप स्वतःची पुनर्रचना होते. मिन-हिपच्या बाबतीत, सर्वात लहान घटक त्याच्या घालण्याच्या क्रमाकडे दुर्लक्ष करून रूटवर जातो. या मिन-हिपवर आधारित प्राधान्य रांग. याचा अर्थ, संख्यांच्या रांगेतील घटकांच्या बाबतीत, रांगेतील पहिला घटक या संख्यांपैकी किमान असेल. तुम्ही रूट हटवल्यास, पुढील सर्वात लहान रूट होईल.
चला आपल्या उदाहरणाकडे वळूया.
पायरी 1. आम्ही प्राधान्य रांगेत '5' ठेवतो. ते मूळ बनते. पायरी 2. आम्ही प्राधान्य रांगेत '4' जोडतो. 4 <5, त्यामुळे नवीन घटक जुन्या घटकापेक्षा जास्त असावा. 4 मूळ बनते, 5 त्याचे डावे मूल आहे. आता Java मधील डेटा स्ट्रक्चर आहे [4, 5] पायरी 3. आम्ही '3' जोडतो. तात्पुरते ते मूळचे योग्य मूल बनते (4). तथापि, 3 < 4, म्हणून आपण ते वर उचलले पाहिजे. एक्सचेंज 3 आणि 4. आता आपल्याकडे एक रचना आहे जसे की [3, 5, 4] चरण 4. आपण '2' जोडतो. ते 5 चे डावे मूल बनते. 2<5, म्हणून त्यांची देवाणघेवाण करा. 2 हे 3, 2 < 3 चे डावे मूल बनते, त्यामुळे आणखी एक विनिमय प्रक्रिया. आता आपल्याकडे रचना आहे [२,३,४,५] पायरी ५.आम्ही '1' जोडतो. ते 3 च्या उजव्या मुलापासून 2 च्या डाव्या मुलाकडे येते आणि नंतर मूळकडे जाते. परिणाम डेटा संरचना: [१,२,४,५,३] काढण्याची प्रक्रिया मुळापासून सुरू होते आणि ती उलट प्रक्रियांना उत्तेजन देते. तर, प्रथम आपल्याकडे रूट म्हणून 1, नंतर 2, 3, 4 आणि शेवटी 5 आहे. म्हणूनच ऑपरेशन poll() काढून टाकणे वापरणे.
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) किमान घटक मिळवण्यासाठी देते.
प्राधान्य रांग म्हणजे काय? सर्व प्रथम, हा एक वर्ग आहे जो मागच्या बाजूने घटक घालण्याच्या आणि डोक्यातून घटक काढून टाकण्याच्या बाबतीत रांग इंटरफेसची अंमलबजावणी करतो. मात्र आतमध्ये ही नेहमीची रांग नाही. Java अग्रक्रम रांगेतील घटकांचा क्रम घटकांच्या अग्रक्रमावर अवलंबून असतो. सर्वोच्च प्राधान्य असलेला घटक रांगेच्या शीर्षस्थानी हलविला जाईल. तुम्ही सर्वोच्च रँक असलेला घटक हटवल्यास (सर्व्ह) केल्यास, दुसरा त्याची कॉफी घेण्यासाठी डोक्यावर जाईल. प्राधान्य कसे ठरवले जाते? दस्तऐवजीकरणानुसार, प्राधान्य रांगेतील घटक त्यांच्या नैसर्गिक क्रमानुसार किंवा रांगेच्या बांधकामाच्या वेळी प्रदान केलेल्या तुलनाकर्त्याद्वारे, कोणता कन्स्ट्रक्टर वापरला जातो यावर अवलंबून असतो. प्राधान्य मिन हीपवर आधारित अग्रक्रम रांग. याचा अर्थ, संख्या रांगेतील घटकांच्या बाबतीत, रांगेचा पहिला घटक या संख्यांपैकी किमान असेल. बर्‍याचदा ही व्याख्या वाचल्यानंतर धूर्त विद्यार्थी विचार करू लागतात की प्राधान्य रांग एका रेखीय अर्थाने क्रमवारी लावली जाते. म्हणजेच, जर, म्हणा, आपण एक रांग वापरतो ज्याचे घटक नैसर्गिक संख्या आहेत, तर पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा असेल. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया. मग पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया. मग पहिला घटक सर्वात लहान असेल आणि शेवटचा - सर्वात मोठा. हे पूर्णपणे खरे नाही. प्राधान्य रांग प्रत्यक्षात कशी कार्य करते आणि ती काय देते हे समजून घेण्यासाठी, तुम्हाला हीप कशी कार्य करते हे समजून घेणे आवश्यक आहे. आम्ही थोड्या वेळाने उदाहरण वापरून प्राधान्य रांगेच्या अंतर्गत संरचनेचा विचार करतो. आता त्याच्या बाह्य गुणधर्मांवर लक्ष देऊया.
काढण्याची प्रक्रिया मुळापासून सुरू होते आणि ती उलट प्रक्रियांना उत्तेजन देते. तर, प्रथम आपल्याकडे रूट म्हणून 1, नंतर 2, 3, 4 आणि शेवटी 5 आहे. म्हणूनच ऑपरेशन poll() काढून टाकणे वापरणे.
GO TO FULL VERSION