ஜாவா முன்னுரிமை வரிசை: கிளாசிக்கல் வரிசை அல்ல

இந்தக் கட்டுரையில், வரிசை இடைமுகத்தைச் செயல்படுத்தும் முன்னுரிமை வரிசையான ஜாவா வகுப்பைக் கற்றுக்கொள்கிறோம். வழக்கமான வரிசை இடைமுகத்தைப் பற்றி ஒரு புரோகிராமருக்கு என்ன தெரியும்? முதலாவதாக, இந்த இடைமுகம் FIFO கொள்கை அல்லது "முதலில் முதலில்" அடிப்படையாக கொண்டது. இது வழக்கமான வரிசையை அதன் பொதுவான அர்த்தத்தில் நினைவூட்டுகிறது. McDrive இலிருந்து காபி பெற விரும்புகிறீர்களா? உங்கள் கார் முதலில் ஜன்னலுக்கு அருகில் இருந்தால், அடுத்து வரும் டிரைவருக்கு முன் காபி கிடைக்கும்.

வரிசை இடைமுக அறிவிப்பு

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)

நீங்கள் பார்ப்பது போல், எலிமெண்ட்() முறையைப் பயன்படுத்தி காலியான வரிசையின் தலையை அச்சிட முயற்சிப்பது 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 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]

சரி, இணைக்கப்பட்ட பட்டியல் வரிசை யூகிக்கக்கூடியது மற்றும் புரிந்துகொள்ளக்கூடியது. இது FIFO கொள்கையின்படி வரிசைப்படுத்தப்பட்டுள்ளது. நாங்கள் 5 உடன் தொடங்கினோம், எனவே இந்த உறுப்பு வரிசையில் முதன்மையானது, பின்னர் 4 மற்றும் பல. முன்னுரிமை வரிசை வரிசை பற்றி நாம் என்ன சொல்ல முடியும்? முன்னுரிமை வரிசையின் கூறுகள் அவற்றின் இயல்பான வரிசைப்படி அல்லது வரிசை கட்டும் நேரத்தில் வழங்கப்பட்ட ஒப்பீட்டாளரால் வரிசைப்படுத்தப்படுகின்றன என்று டாக்ஸ் கூறியது. இருப்பினும் இந்த வரிசையானது நேரியல் வரிசையாக்க அர்த்தத்தில் "இயற்கையானது" என்று தெரியவில்லை. நாங்கள் எதிர்பார்க்கிறோம் [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());
       }

நாம் நேரியல் சென்ஸ் வெளியீட்டில் "வரிசைப்படுத்தப்பட்டுள்ளோம்":

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 த்ரெட் பாதுகாப்பானது அல்ல, எனவே ஒரே நேரத்தில் வேலை செய்ய PriorityBlockingQueue ஐப் பயன்படுத்துவது நல்லது.
• PriorityQueue, சேர்க்க மற்றும் வாக்கெடுப்பு முறைகளுக்கு O(log(n)) நேரத்தையும், O(1) குறைந்த உறுப்புகளைப் பெறுவதற்கும் வழங்குகிறது.