இந்தக் கட்டுரையில், வரிசை இடைமுகத்தைச் செயல்படுத்தும் முன்னுரிமை வரிசையான ஜாவா வகுப்பைக் கற்றுக்கொள்கிறோம். வழக்கமான வரிசை இடைமுகத்தைப் பற்றி ஒரு புரோகிராமருக்கு என்ன தெரியும்? முதலாவதாக, இந்த இடைமுகம் FIFO கொள்கை அல்லது "முதலில் முதலில்" அடிப்படையாக கொண்டது. இது வழக்கமான வரிசையை அதன் பொதுவான அர்த்தத்தில் நினைவூட்டுகிறது. McDrive இலிருந்து காபி பெற விரும்புகிறீர்களா? உங்கள் கார் முதலில் ஜன்னலுக்கு அருகில் இருந்தால், அடுத்து வரும் டிரைவருக்கு முன் காபி கிடைக்கும்.
![ஜாவா முன்னுரிமை வரிசை: கிளாசிக்கல் வரிசை அல்ல - 2]()
முன்னுரிமை வரிசை என்றால் என்ன? முதலாவதாக, பின்பகுதியிலிருந்து ஒரு உறுப்பைச் செருகி, தலையிலிருந்து ஒரு உறுப்பை அகற்றினால், வரிசை இடைமுகத்தை செயல்படுத்தும் ஒரு வகுப்பு இது. ஆனால் உள்ளே அது வழக்கமான வரிசையில் இல்லை. ஜாவா முன்னுரிமை வரிசை உறுப்புகளின் வரிசை உறுப்புகளின் முன்னுரிமையைப் பொறுத்தது. அதிக முன்னுரிமை கொண்ட உறுப்பு வரிசையின் தலைக்கு நகர்த்தப்படும். உயர்ந்த தரவரிசையில் உள்ள உறுப்பை நீங்கள் நீக்கினால் (சேவை செய்தால்), இரண்டாவது அதன் காபியைப் பெற தலைக்குச் செல்கிறது. முன்னுரிமை எவ்வாறு தீர்மானிக்கப்படுகிறது? ஆவணங்களின்படி, முன்னுரிமை வரிசையின் கூறுகள் அவற்றின் இயற்கையான வரிசைமுறையின்படி வரிசைப்படுத்தப்படுகின்றன அல்லது வரிசை கட்டும் நேரத்தில் வழங்கப்பட்ட ஒப்பீட்டாளரால், எந்தக் கட்டமைப்பாளர் பயன்படுத்தப்படுகிறார் என்பதைப் பொறுத்து. முன்னுரிமை நிமிடக் குவியலின் அடிப்படையில் முன்னுரிமை வரிசை. அதாவது, எண்கள் வரிசை உறுப்புகளின் விஷயத்தில், வரிசையின் முதல் உறுப்பு இந்த எண்களின் குறைந்தபட்சமாக இருக்கும். இந்த வரையறையைப் படித்த பிறகு பெரும்பாலும் புதிய மாணவர்கள் முன்னுரிமை வரிசை நேரியல் அர்த்தத்தில் வரிசைப்படுத்தப்பட்டதாக நினைக்கத் தொடங்குகின்றனர். அதாவது, இயற்கை எண்களைக் கொண்ட ஒரு வரிசையை நாம் பயன்படுத்தினால், முதல் உறுப்பு சிறியதாகவும், கடைசியாக - மிகப்பெரியதாகவும் இருக்கும். இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம். பின்னர் முதல் உறுப்பு சிறியதாக இருக்கும், மற்றும் கடைசி - பெரியது. இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம். பின்னர் முதல் உறுப்பு சிறியதாக இருக்கும், மற்றும் கடைசி - பெரியது. இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம்.
![ஜாவா முன்னுரிமை வரிசை: கிளாசிக்கல் வரிசை அல்ல - 3]()
அகற்றுதல் செயல்முறை ஒரு மூலத்திலிருந்து தொடங்குகிறது, மேலும் இது தலைகீழ் நடைமுறைகளைத் தூண்டுகிறது. எனவே, முதலில் 1ஐ ரூட்டாகவும், பிறகு 2, 3, 4 ஆகவும், கடைசியாக 5 ஆகவும் இருக்கிறோம். அதனால்தான் ரிமூவ் ஆபரேஷன் வாக்கெடுப்பைப் பயன்படுத்துகிறோம்()
வரிசை இடைமுக அறிவிப்பு
public interface Queue<E> extends Collection<E>
முன்னுரிமை வரிசை என்றால் என்ன
முன்னுரிமை வரிசை என்றால் என்ன? முதலாவதாக, பின்பகுதியிலிருந்து ஒரு உறுப்பைச் செருகி, தலையிலிருந்து ஒரு உறுப்பை அகற்றினால், வரிசை இடைமுகத்தை செயல்படுத்தும் ஒரு வகுப்பு இது. ஆனால் உள்ளே அது வழக்கமான வரிசையில் இல்லை. ஜாவா முன்னுரிமை வரிசை உறுப்புகளின் வரிசை உறுப்புகளின் முன்னுரிமையைப் பொறுத்தது. அதிக முன்னுரிமை கொண்ட உறுப்பு வரிசையின் தலைக்கு நகர்த்தப்படும். உயர்ந்த தரவரிசையில் உள்ள உறுப்பை நீங்கள் நீக்கினால் (சேவை செய்தால்), இரண்டாவது அதன் காபியைப் பெற தலைக்குச் செல்கிறது. முன்னுரிமை எவ்வாறு தீர்மானிக்கப்படுகிறது? ஆவணங்களின்படி, முன்னுரிமை வரிசையின் கூறுகள் அவற்றின் இயற்கையான வரிசைமுறையின்படி வரிசைப்படுத்தப்படுகின்றன அல்லது வரிசை கட்டும் நேரத்தில் வழங்கப்பட்ட ஒப்பீட்டாளரால், எந்தக் கட்டமைப்பாளர் பயன்படுத்தப்படுகிறார் என்பதைப் பொறுத்து. முன்னுரிமை நிமிடக் குவியலின் அடிப்படையில் முன்னுரிமை வரிசை. அதாவது, எண்கள் வரிசை உறுப்புகளின் விஷயத்தில், வரிசையின் முதல் உறுப்பு இந்த எண்களின் குறைந்தபட்சமாக இருக்கும். இந்த வரையறையைப் படித்த பிறகு பெரும்பாலும் புதிய மாணவர்கள் முன்னுரிமை வரிசை நேரியல் அர்த்தத்தில் வரிசைப்படுத்தப்பட்டதாக நினைக்கத் தொடங்குகின்றனர். அதாவது, இயற்கை எண்களைக் கொண்ட ஒரு வரிசையை நாம் பயன்படுத்தினால், முதல் உறுப்பு சிறியதாகவும், கடைசியாக - மிகப்பெரியதாகவும் இருக்கும். இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம். பின்னர் முதல் உறுப்பு சிறியதாக இருக்கும், மற்றும் கடைசி - பெரியது. இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம். பின்னர் முதல் உறுப்பு சிறியதாக இருக்கும், மற்றும் கடைசி - பெரியது. இது முற்றிலும் உண்மையல்ல. முன்னுரிமை வரிசை உண்மையில் எவ்வாறு செயல்படுகிறது மற்றும் அது என்ன தருகிறது என்பதைப் புரிந்து கொள்ள, குவியல் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும். சிறிது நேரம் கழித்து ஒரு உதாரணத்தைப் பயன்படுத்தி முன்னுரிமை வரிசையின் உள் கட்டமைப்பை நாங்கள் கருதுகிறோம். இப்போது அதன் வெளிப்புற பண்புகளில் வாழ்வோம்.
முன்னுரிமை வரிசை வகுப்பு கட்டமைப்பாளர்கள் மற்றும் அறிவிப்பு
PriorityQueue வகுப்பு ஜாவாவில் முன்னுரிமை வரிசையை உருவாக்க 6 வெவ்வேறு வழிகளை வழங்குகிறது.- PriorityQueue() - இயல்புநிலை ஆரம்ப திறன் (11) கொண்ட வெற்று வரிசை, அதன் கூறுகளை அவற்றின் இயற்கையான வரிசைப்படி ஆர்டர் செய்கிறது.
- முன்னுரிமை வரிசை(சேகரிப்பு 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<>();
ஜாவா முன்னுரிமை வரிசை முறைகள்
PriorityQueue Java வகுப்பில் உறுப்புகளைச் சேர்க்க, அகற்ற மற்றும் சரிபார்க்க முக்கியமான முறைகள் உள்ளன.முன்னுரிமை வரிசையில் உறுப்புகளைச் செருகவும்
- 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)
முன்னுரிமை வரிசை ஒப்பீட்டாளர்
- ஒப்பீட்டாளர் ஒப்பீட்டாளர்() வரிசையில் உள்ள உறுப்புகளை வரிசைப்படுத்தப் பயன்படுத்திய ஒப்பீட்டாளரை வழங்குகிறது. வரிசை அதன் உறுப்புகளின் இயல்பான வரிசைப்படி வரிசைப்படுத்தப்பட்டால் பூஜ்யமாகத் திரும்பும்.
ஜாவா முன்னுரிமை வரிசை, ஒப்பீட்டாளருடன் உதாரணம்
மேலே உள்ள குறியீடு எடுத்துக்காட்டுகளில் இயற்கையான (ஏறும்) வரிசையைப் பயன்படுத்தினோம், ஆனால் சில நேரங்களில் அதை மாற்ற வேண்டும். ஜாவா முன்னுரிமை வரிசை உதாரணம் இங்கே உள்ளது, இங்கு நாம் ஒப்பீட்டாளர் இடைமுகத்தை செயல்படுத்தும் எங்கள் சொந்த உள் ஒப்பீட்டு வகுப்பை உருவாக்குகிறோம். எங்கள் ஒப்பீட்டாளர் கூறுகளை பெரியது முதல் சிறியது வரை வரிசைப்படுத்துவார்.
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 contains(Object 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 வரையறை
நீங்கள் முன்னுரிமை வரிசை ஜாவா 8 ஆவணத்தைத் திறந்தால், அடுத்த வரையறையை நீங்கள் காணலாம்: முன்னுரிமைக் குவியலின் அடிப்படையில் வரம்பற்ற முன்னுரிமை வரிசை. முன்னுரிமை வரிசையின் கூறுகள் அவற்றின் இயற்கையான வரிசைப்படி அல்லது வரிசை கட்டும் நேரத்தில் வழங்கப்படும் ஒப்பீட்டாளரால் வரிசைப்படுத்தப்படுகின்றன, இது எந்தக் கட்டமைப்பாளர் பயன்படுத்தப்படுகிறது என்பதைப் பொறுத்து. முன்னுரிமை வரிசை பூஜ்ய கூறுகளை அனுமதிக்காது. இயற்கையான வரிசைமுறையை நம்பியிருக்கும் முன்னுரிமை வரிசையானது ஒப்பிட முடியாத பொருட்களைச் செருகுவதை அனுமதிக்காது (அவ்வாறு செய்தால் ClassCastException ஏற்படலாம்). இங்கு குவியல் என்பது மிக முக்கியமான சொல். இது முன்னுரிமை வரிசை உறுப்புகளை வரிசைப்படுத்தும் பண்புகளை விளக்குகிறது.முன்னுரிமை வரிசை வேலையின் கொள்கை: பைனரி குவியல்
ஒரு உதாரணத்துடன் ஆரம்பிக்கலாம். வரிசை இடைமுகத்தை செயல்படுத்தும் இரண்டு பொருட்களை உருவாக்குவோம். அவற்றில் ஒன்று இணைக்கப்பட்ட பட்டியல், இரண்டாவது - முன்னுரிமை வரிசை. அவை இரண்டும் 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]
நமது உதாரணத்திற்கு வருவோம்.
படி 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
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 த்ரெட் பாதுகாப்பானது அல்ல, எனவே ஒரே நேரத்தில் வேலை செய்ய PriorityBlockingQueue ஐப் பயன்படுத்துவது நல்லது.
- PriorityQueue, சேர்க்க மற்றும் வாக்கெடுப்பு முறைகளுக்கு O(log(n)) நேரத்தையும், O(1) குறைந்த உறுப்புகளைப் பெறுவதற்கும் வழங்குகிறது.
GO TO FULL VERSION