# Implement PriorityQueue through Comparator in Java

• Difficulty Level : Medium
• Last Updated : 19 Jul, 2019

Prerequisite : Priority Queue, Comparator
Priority Queue is like a regular queue, but each element has a “priority” associated with it. In a priority queue, an element with high priority is served before an element with low priority. For this, it uses a comparison function which imposes a total ordering of the elements.

The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time, depending on which constructor is used

Constructors :

1. public PriorityQueue() : This creates a PriorityQueue with the default initial capacity (11) that orders its elements according to their natural ordering.
2. public PriorityQueue(Collection c) : This creates a PriorityQueue containing the elements in the specified collection(c). If the specified collection is an instance of a SortedSet, this priority queue will be ordered according to the same ordering, else this priority queue will be ordered according to the natural ordering of its elements.
3. public PriorityQueue(int capacity, Comparator comparator) : This creates a PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator.
```Parameters:
capacity - the initial capacity for this priority queue
comparator - the comparator that will be used to order this priority queue.
If null, the natural ordering of the elements will be used.
```
4. public PriorityQueue(SortedSet ss) : Creates a PriorityQueue containing the elements in the specified sorted set. This priority queue will be ordered according to the same ordering as the given sorted set.

Sample code provided illustrates students with high priority(based on cgpa) are served before the students having low cgpa.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

 `// Java program to demonstrate working of ``// comparator based priority queue constructor``import` `java.util.*;`` ` `public` `class` `Example {``    ``public` `static` `void` `main(String[] args){``        ``Scanner in = ``new` `Scanner(System.in);``        ``// Creating Priority queue constructor having ``        ``// initial capacity=5 and a StudentComparator instance ``        ``// as its parameters``        ``PriorityQueue pq = ``new` `             ``PriorityQueue(``5``, ``new` `StudentComparator());``                 ` `                ``// Invoking a parameterized Student constructor with ``                ``// name and cgpa as the elements of queue``                ``Student student1 = ``new` `Student(``"Nandini"``, ``3.2``);``                 ` `                ``// Adding a student object containing fields ``                ``// name and cgpa to priority queue ``                ``pq.add(student1);``                ``Student student2 = ``new` `Student(``"Anmol"``, ``3.6``);``                        ``pq.add(student2);         ``                ``Student student3 = ``new` `Student(``"Palak"``, ``4.0``);``                        ``pq.add(student3);``                 ` `                ``// Printing names of students in priority order,poll()``                ``// method is used to access the head element of queue``                ``System.out.println(``"Students served in their priority order"``);``                 ` `                ``while` `(!pq.isEmpty()) {``                ``System.out.println(pq.poll().getName());``        ``} ``    ``}``} `` ` `class` `StudentComparator ``implements` `Comparator{``             ` `            ``// Overriding compare()method of Comparator ``                        ``// for descending order of cgpa``            ``public` `int` `compare(Student s1, Student s2) {``                ``if` `(s1.cgpa < s2.cgpa)``                    ``return` `1``;``                ``else` `if` `(s1.cgpa > s2.cgpa)``                    ``return` `-``1``;``                                ``return` `0``;``                ``}``        ``}`` ` `class` `Student {``    ``public` `String name;``    ``public` `double` `cgpa;``         ` `    ``// A parameterized student constructor``    ``public` `Student(String name, ``double` `cgpa) {``     ` `        ``this``.name = name;``        ``this``.cgpa = cgpa;``    ``}``     ` `    ``public` `String getName() {``        ``return` `name;``    ``} ``}`

Output:

```Students served in their priority order
Palak
Anmol
Nandini
```

Note : This type of Priority queue is preferred in scenarios where customized ordering is required, i.e when one wants a different sorting order, then one can define its own way of comparing instances. Comparator can be implemented if there is a more complex comparing algorithm, e.g. multiple fields and so on.

My Personal Notes arrow_drop_up