- Related Questions & Answers
- Meldable Priority Queue Operations
- The Priority Queue in Javascript
- Multithreaded Priority Queue in Python
- Creating a Priority Queue using Javascript
- C++ Program to Implement Priority Queue
- Priority Queue Introduction in C/C++
- Dequeue and Priority Queue in C++
- Priority Queue using Linked List in C
- Priority Queue using doubly linked list in C++
- Priority Queue in C++ Standard Template Library (STL)
- STL Priority Queue for Structure or Class in C++
- How to create Java Priority Queue to ignore duplicates?
- Priority queue of pairs in C++ (Ordered by first)
- How to append data from priority queue to arraylist for listview in Android?
- HTML DOM Video ended Property

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

A double-ended priority queue (DEPQ) or double-ended heap is defined as a data structure like a priority queue or heap, but permits for efficient removal of both the maximum and minimum, according to some ordering on the keys or items stored in the structure. Every element in a DEPQ associated with a priority or value. In a DEPQ, it is possible to eliminate or remove the elements in both ascending and descending order.

**Operations**

A double-ended priority queue consists of the following operations

**isEmpty()**

This function is responsible to check if DEPQ is empty and returns true if empty.

**size()**

This function is responsible to return the total number of elements present in the DEPQ.

**getMin(y)**

This function is responsible to return the element y having least priority.

**getMax(y)**

This function is responsible to return the element y having highest priority.

**put(y)**

This function is responsible to insert the element y in the DEPQ.

**removeMin(y)**

This function is responsible to remove an element y with minimum priority and return this element.

**removeMax(y)**

This function is responsible to remove an element y with maximum priority and return this element.

Double-ended priority queues can be built or formed from balanced binary search trees (where the smallest and largest elements are treated as the leftmost and rightmost leaves, respectively), or implementing specialized data structures like min-max heap and pairing heap.

Generic methods of arriving at double-ended priority queues from normal priority queues are:

According to this method, two different priority queues for min and max are set or maintained. The same elements in both the priority queues are displayed or shown with the help of correspondence pointers.

Here, the minimum and maximum elements are denoted as the values contained in the root nodes of min heap and max heap respectively.

**Removing the min element** − Operate removemin() on the min heap and remove(node value) on the max heap, where node value is defined as the value in the corresponding node in the max heap.

**Removing the max element** − Operate removemax() on the max heap and remove(node value) on the min heap, where node value is defined as the value in the corresponding node in the min heap.

Half the elements are in the min priority queue and the other half in the max priority queue. Each element in the min priority queue has a one-to-one correspondence with an element in max priority queue. If the number of elements in the DEPQ indicates odd value, one of the elements is retained in a buffer i.e. a specific storage area. Priority of every element in the min priority queue will be less than or equal to the corresponding element in the max priority queue.

According to this method only the leaf elements of the min and max priority queue form corresponding one-to-one pairs. It is not required for non-leaf elements to be in a one-to-one correspondence pair.

Besides the above-mentioned correspondence methods, DEPQ's can be obtained perfectly implementing interval heaps. An interval heap is like an embedded min-max heap in which each node consists of two elements. It is defined as a complete binary tree in which −

- The left element is always less than or equal to the right element.
- Both the elements define or specify a closed interval.
- Interval represented by any node except the root is denoted as a sub-interval of the parent node.
- Elements on the left hand side define or denote a min heap.
- Elements on the right hand side define or denote a max heap.

Advertisements