Program to Handle Duplicate Elements in a PriorityQueue
Approach 1: Using a Custom Comparator
Below is the implementation of Handling Duplicate Elements in a PriorityQueue:
Java
// Java program to handle duplicate elements in a PriorityQueue while maintaining order // using a custom comparator import java.util.Comparator; import java.util.PriorityQueue; public class PriorityQueueExample { public static void main(String[] args) { // Custom comparator to maintain order for duplicates Comparator<Integer> customComparator = (a, b) -> { int result = Integer.compare(a % 10 , b % 10 ); return result == 0 ? Integer.compare(a, b) : result; }; // PriorityQueue with custom comparator PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(customComparator); // Adding elements to PriorityQueue priorityQueue.add( 15 ); priorityQueue.add( 22 ); priorityQueue.add( 11 ); priorityQueue.add( 22 ); // Duplicate element priorityQueue.add( 30 ); // Polling elements from PriorityQueue while (!priorityQueue.isEmpty()) { System.out.println(priorityQueue.poll()); } } } |
30 11 22 22 15
Explanation of the above Program:
- In this example, we specify a particular ordering for the entries in the PriorityQueue by creating a custom comparator.
- The comparator evaluates and contrasts each element’s last digit. It compares the items directly if the last digits are the same.
- In this manner, the custom comparator determines the order of duplicate items when they are encountered.
- After that, elements including duplicates are added to the PriorityQueue and polled in the proper sequence.
Approach 2: Using a Wrapper Class
Below is the implementation of the a Wrapper Class for handling elements in PriorityQueue:
Java
// Java program to handle duplicate elements in a PriorityQueue while maintaining order // using a wrapper class import java.util.PriorityQueue; public class ElementWrapper implements Comparable<ElementWrapper> { int value; public ElementWrapper( int value) { this .value = value; } @Override public int compareTo(ElementWrapper other) { return Integer.compare( this .value % 10 , other.value % 10 ); } public static void main(String[] args) { // PriorityQueue with ElementWrapper PriorityQueue<ElementWrapper> priorityQueue = new PriorityQueue<>(); // Adding elements to PriorityQueue priorityQueue.add( new ElementWrapper( 15 )); priorityQueue.add( new ElementWrapper( 22 )); priorityQueue.add( new ElementWrapper( 11 )); priorityQueue.add( new ElementWrapper( 22 )); // Duplicate element priorityQueue.add( new ElementWrapper( 30 )); // Polling elements from PriorityQueue while (!priorityQueue.isEmpty()) { System.out.println(priorityQueue.poll().value); } } } |
30 11 22 22 15
Explanation of the above Program:
- In this example we provide a wrapper class that implements the Comparable interface called ElementWrapper.
- The wrapper class’s compareTo function is modified to compare components according to the last digit.
- Next, ElementWrapper objects are used to instantiate the PriorityQueue, guaranteeing that duplicate items are identified according to their inherent ordering.
- When duplicates are present, the PriorityQueue is filled, and items are polled to display the maintained order.
Java Program to Handle Duplicate Elements in a PriorityQueue While Maintaining Order
In Java, elements in a Priority Queue are arranged according to their priority, which is based on a priority heap. When there are duplicate items, the default comparison method is to use a comparator that is given or to compare the elements according to their natural ordering. We can use a custom comparator or wrapper class to handle duplicates and preserve order.
In this article, we will learn how to handle duplicate elements in a PriorityQueue while maintaining order in Java.
Approaches to Handle Duplicates in a Priority Queue
By using two methods we can handle duplicate elements in a Priority Queue while maintaining order.
- Using a Custom Comparator
- Using a Wrapper Class