Double Ended Priority Queue

Introduction to the double-ended priority queue

A double-ended priority queue (DEPQ) is a data structure that stores a collection of elements, where each element is associated with a priority or value. Elements can be inserted and removed from both ends of the queue based on their priority.

The highest priority element can be accessed from either end of the queue without removing it. In a DEPQ, the elements are stored in a way that maintains their priority order, such that the highest priority element is always at the front or back of the queue, depending on the implementation.

Basic Terms:

Priority Queue - A priority queue is a collection of items where each item has a priority assigned to it, and the items are handled in priority order.

Double-Ended Queue - A double-ende queue is a collection of items that permits insertion and deletion from both the front and the back of the queue

Properties of DEPQ

A DEPQ permits actions like inserting and deleting items with priorities at both ends of the queue.
In spite of where they are in the queue, the elements with higher priorities are always processed first.
The DEPQ is a valuable data structure for scheduling, task management, and resource allocation applications because of this.
Several data structures, including binary heaps, Fibonacci heaps, and balanced binary search trees, can be used to build DEPQs.
The needs of the particular application and the trade-offs between time and space complexity determine the best data structure to use.

Operations supported by DEPQs

The following operations are performed on a double-ended priority queue (DEPQ):

getMin(): This function returns the minimum element.
getMax(): This function returns the maximum element
put(x): This function inserts the element 'x' into the DEPQ.
removeMin(): As the name indicates, it removes the minimum element from DEPQ
removeMax(): It removes the maximum element from the DEPQ.

Self-balancing BST implementation of a DEPQ

A self-balancing BST implementation of a DEPQ provides effective time complexity for all of its operations, and its space complexity is comparable to that of other implementations. Self-balancing trees automatically retain their balanced structure, ensuring quick and reliable performance while working with big data sets.

In C++, a self-balancing binary search tree, such as red-black or AVL trees, is commonly used to implement the set container. These data structures offer set operations with effective worst-case and average-case time complexity.

// C++ program to implement double-ended
// priority queue using self-balancing BST
#include <iostream>
#include <set>

using namespace std;

// Defining DEPQ class
class DEPQ
{
private:
    set<int> s;

public:
    // Insert a value into the DEPQ
    // Time Complexity = O(Log n)
    void put(int val)
    {
        s.insert(val);
    }

    // Get the minimum value in the DEPQ
    // Time Complexity = O(1)
    int getMin()
    {
        return *s.begin();
    }

    // Get the maximum value in the DEPQ
    // Time Complexity = O(1)
    int getMax()
    {
        return *prev(s.end());
    }

    // Delete the minimum value from the DEPQ
    // Time Complexity = O(Log n)
    void removeMin()
    {
        if (!s.empty())
        {
            s.erase(s.begin());
        }
    }

    // Delete the maximum value from the DEPQ
    // Time Complexity = O(Log n)
    void removeMax()
    {
        if (!s.empty())
        {
            s.erase(prev(s.end()));
        }
    }

    // Get the size of the DEPQ
    // Time Complexity = O(1)
    int size()
    {
        return s.size();
    }

    // Check if the DEPQ is empty
    // Time Complexity = O(1)
    bool isEmpty()
    {
        return s.empty();
    }
};

// Driver function
int main()
{
    DEPQ d;

    int choice, val;

    // Printing Options
    cout << "\nDEPQ Operations:" << endl;
    cout << "1. Insert an Element" << endl;
    cout << "2. Get Minimum Element" << endl;
    cout << "3. Get Maximum Element" << endl;
    cout << "4. Delete Minimum Element" << endl;
    cout << "5. Delete Maximum Element" << endl;
    cout << "6. Size" << endl;
    cout << "7. Is Empty?" << endl;
    cout << "0. Exit" << endl;

    do
    {
        cout << "Enter your choice: ";
        cin >> choice;

        // Switched case is used to make this program user driven.
        switch (choice)
        {

        // Case 1 to insert
        case 1:
            cout << "Enter the value to put: ";
            cin >> val;
            d.put(val);
            cout << "Value inserted successfully." << endl;
            break;

        // Case 2 to get minimum element
        case 2:
            if (!d.isEmpty())
            {
                cout << "Minimum value: " << d.getMin() << endl;
            }
            else
            {
                cout << "DEPQ is empty." << endl;
            }
            break;

        // Case 3 to get maximum element
        case 3:
            if (!d.isEmpty())
            {
                cout << "Maximum value: " << d.getMax() << endl;
            }
            else
            {
                cout << "DEPQ is empty." << endl;
            }
            break;

        // Case 4 to remove minimum element
        case 4:
            if (!d.isEmpty())
            {
                d.removeMin();
                cout << "Minimum value deleted successfully." << endl;
            }
            else
            {
                cout << "DEPQ is empty." << endl;
            }
            break;

        // Case 5 to remove maximum element
        case 5:
            if (!d.isEmpty())
            {
                d.removeMax();
                cout << "Maximum value deleted successfully." << endl;
            }
            else
            {
                cout << "DEPQ is empty." << endl;
            }
            break;

        // Case 6 to find the size of the DEPQ
        case 6:
            cout << "DEPQ size: " << d.size() << endl;
            break;

        // Case 1 to check emptiness of DEPQ
        case 7:
            if (d.isEmpty())
            {
                cout << "DEPQ is empty." << endl;
            }
            else
            {
                cout << "DEPQ is not empty." << endl;
            }
            break;

        // Case 0 to exit
        case 0:
            cout << "Successfully Exited!" << endl;
            break;

        // Default
        default:
            cout << "Invalid choice. Please try again." << endl;
        }
    } while (choice != 0);

    return 0;
}

Output

DEPQ Operations:   
1. Insert an Element
2. Get Minimum Element    
3. Get Maximum Element    
4. Delete Minimum Element 
5. Delete Maximum Element 
6. Size
7. Is Empty?       
0. Exit
Enter your choice: 1
Enter the value to put: 25
Value inserted successfully.
Enter your choice: 1
Enter the value to put: 75
Value inserted successfully.
Enter your choice: 1
Enter the value to put: 30
Value inserted successfully.
Enter your choice: 1
Enter the value to put: 90
Value inserted successfully.
Enter your choice: 1
Enter the value to put: 55
Value inserted successfully.
Enter your choice: 6
DEPQ size: 5
Enter your choice: 7
DEPQ is not empty.
Enter your choice: 2
Minimum value: 25
Enter your choice: 3
Maximum value: 90
Enter your choice: 4
Minimum value deleted successfully.
Enter your choice: 5
Maximum value deleted successfully.
Enter your choice: 2
Minimum value: 30
Enter your choice: 3
Maximum value: 75
Enter your choice: 0
Successfully Exited!

Time Complexity of each function:

put()	O(logn)
removeMin()	O(logn)
removeMax()	O(logn)
getMin()	O(1)
getMax()	O(1)
size()	O(1)
isEmpty()	O(1)

Implementation of Double-Ended Priority Queue in Java

In this implementation, we used a TreeSet to store the elements in a sorted manner. The TreeSet allows us to easily retrieve the minimum and maximum elements and also perform insertion and deletion in O(log n) time complexity.

// Java Program to implement DEPQ using self-balancing BST (TreeSet)
import java.util.TreeSet;

class DblEndedPQ {

    private TreeSet<Integer> treeSet;

    public DblEndedPQ() {
        treeSet = new TreeSet<Integer>();
    }

    // Returns size of the queue.
    // Time Complexity = O(1)
    public int size() {
        return treeSet.size();
    }

    // Returns true if the queue is empty.
    // Time Complexity = O(1)
    public boolean isEmpty() {
        return treeSet.isEmpty();
    }

    // Inserts an element.
    // Time Complexity = O(Log n)
    public void put(int x) {
        treeSet.add(x);
    }

    // Returns minimum element.
    // Time Complexity = O(1)
    public int getMin() {
        return treeSet.first();
    }

    // Returns maximum element.
    // Time Complexity = O(1)
    public int getMax() {
        return treeSet.last();
    }

    // Deletes minimum element.
    // Time Complexity = O(Log n)
    public void removeMin() {
        if (!treeSet.isEmpty()) {
            treeSet.pollFirst();
        }
    }

    // Deletes maximum element.
    // Time Complexity = O(Log n)
    public void removeMax() {
        if (!treeSet.isEmpty()) {
            treeSet.pollLast();
        }
    }
}

public class Main {

    public static void main(String[] args) {
        // Creating a DblEndedPQ Object
        DblEndedPQ depq = new DblEndedPQ();

        // Inserting Elements
        depq.put(25);
        System.out.println("Inserted 25 Successfully!");
        depq.put(75);
        System.out.println("Inserted 75 Successfully!");
        depq.put(30);
        System.out.println("Inserted 30 Successfully!");
        depq.put(90);
        System.out.println("Inserted 90 Successfully!");
        depq.put(55);
        System.out.println("Inserted 55 Successfully!");

        // Performing operations
        System.out.println("Size of the DEPQ : " + depq.size());
        System.out.println("Is empty? : " + depq.isEmpty());
        System.out.println("Minimum Element : " + depq.getMin());
        System.out.println("Maximum Element : " + depq.getMax());

        // Deleting the maximum element
        depq.removeMax();
        System.out.println("Maximum Element Deleted Successfully!");
        System.out.println("New Maximum Element : " + depq.getMax());

        // Deleting the maximum element
        depq.removeMin();
        System.out.println("Minimum Element Deleted Successfully!");
        System.out.println("New Minimum Element : " + depq.getMin());

        System.out.println("Size of the DEPQ now : " + depq.size());
    }
}

Output

Inserted 25 Successfully!
Inserted 75 Successfully!
Inserted 30 Successfully!
Inserted 90 Successfully!
Inserted 55 Successfully!
Size of the DEPQ : 5
Is empty? : false
Minimum Element : 25
Maximum Element : 90
Maximum Element Deleted Successfully!
New Maxmium Element : 75
Minimum Element Deleted Successfully!
New Minimum Element : 30
Size of the DEPQ now : 3

Implementation of Double-Ended Priority Queue in Python

The bisect module, which supports maintaining a list in sorted order without requiring the list to be sorted after each insertion, is used in this implementation. Using the bisect.insort() function, the element is inserted in the proper spot to preserve the sorted order. This enables us to insert and delete items in operations of O(log n) time complexity and obtain the minimum and the maximum elements in O(1) time.

import bisect

class DblEndedPQ:

    def __init__(self):
        self.lst = []

    # Returns the size of the queue.
    # Time Complexity = O(1)
    def size(self):
        return len(self.lst)

    # Returns true if the queue is empty.
    # Time Complexity = O(1)
    def isEmpty(self):
        return len(self.lst) == 0

    # Inserts an element.
    # Time Complexity = O(Log n)
    def insert(self, x):
        bisect.insort(self.lst, x)

    # Returns minimum element.
    # Time Complexity = O(1)
    def getMin(self):
        return self.lst[0]

    # Returns maximum element.
    # Time Complexity = O(1)
    def getMax(self):
        return self.lst[-1]

    # Deletes minimum element.
    # Time Complexity = O(Log n)
    def deleteMin(self):
        if not self.isEmpty():
            self.lst.pop(0)

    # Deletes maximum element.
    # Time Complexity = O(Log n)
    def deleteMax(self):
        if not self.isEmpty():
            self.lst.pop()

# Driver code
if __name__ == '__main__':
    # Creating a DblEndedPQ object
    depq = DblEndedPQ()

    # Inserting elements into DEPQ
    depq.insert(25)
    print("Inserted 25 Successfully!")
    depq.insert(75)
    print("Inserted 75 Successfully!")
    depq.insert(30)
    print("Inserted 30 Successfully!")
    depq.insert(90)
    print("Inserted 90 Successfully!")
    depq.insert(55)
    print("Inserted 55 Successfully!")

    # Performing operations
    print(f"Size of the DEPQ : {depq.size()}")
    print(f"is Empty? : {depq.isEmpty()}")
    print(f"Minimum Element : {depq.getMin()}")
    print(f"Maximum Element : {depq.getMax()}")

    # Deleting Maximum element
    depq.deleteMax()
    print("Maximum Elemented Deleted Successfully!")
    print(f"Maximum Element : {depq.getMax()}")

    # Deleting Minimum element
    depq.deleteMin()
    print("Minimum Elemented Deleted Successfully!")
    print(f"New Minimum Element : {depq.getMin()}")
    print(f"Size of the DEPQ now : {depq.size()}")

Output

Inserted 25 Successfully!
Inserted 75 Successfully!
Inserted 30 Successfully!
Inserted 90 Successfully!
Inserted 55 Successfully!
Size of the DEPQ : 5
is Empty? : False
Minimum Element : 25
Maximum Element : 90
Maximum Elemented Deleted Successfully!
Maximum Element : 75
Minimum Elemented Deleted Successfully!
New Minimum Element : 30
Size of the DEPQ now : 3

Comparing Heap implementation vs. BBST implementation of DEPQ

Implementing a Double-Ended Priority Queue (DEPQ) using a Heap vs. a Balanced Binary Search Tree (BBST):

Heap Implementation:

A Heap is a complete binary tree that satisfies the heap property.
Inserting an element takes O(log n) time, where n is the number of elements in a heap.
Deleting the minimum or maximum element takes O(log n) time.
Getting the minimum or maximum element takes O(1) time.
The space complexity of a heap is O(n).

Balanced Binary Search Tree (BBST) Implementation:

A BBST is a binary tree that satisfies the balance property, such as an AVL or Red-Black tree.
Inserting an element takes O(log n) time, where n is the number of elements in the tree.
Deleting the minimum or maximum element takes O(log n) time.
Getting the minimum or maximum element takes O(log n) time.
The space complexity of a BBST is O(n).

Comparing these two implementations, we can see that:

Heap has a faster time complexity for getting the minimum or maximum element (O(1) vs. O(log n)), but a slower time complexity for inserting and deleting elements (O(log n) vs. O(log n)).
BBST has a slower time complexity for getting the minimum or maximum element but a faster time complexity for inserting and deleting elements.
The space complexity of both implementations is the same.
Therefore, the implementation choice depends on the specific use case and the most frequently performed operations. A heap may be a better choice if getting the minimum or maximum element is a more frequent operation. On the other hand, if inserting and deleting elements are more frequent, then a BBST may be a better choice.

Next TopicB+ Tree Deletion

← prev next →