Priority Queue | Set 1 (Introduction) - GeeksforGeeks

25 Jan, 2022
Priority Queue is an abstract data type, which is similar to a queue, however, in the priority queue, every element has some priority. The priority of the elements in a priority queue determines the order in which elements are removed from the priority queue. Therefore all the elements are either arranged in an ascending or descending order.
So, a priority Queue is an extension of the queue with the following properties. 
Every item has a priority associated with it.
An element with high priority is dequeued before an element with low priority.
If two elements have the same priority, they are served according to their order in the queue.
In the below priority queue, an element with a maximum ASCII value will have the highest priority. The elements with higher priority are served first. 
A typical priority queue supports the following operations:1) Insertion: When a new element is inserted in a priority queue, it moves to the empty slot from top to bottom and left to right. However, if the element is not in the correct place then it will be compared with the parent node. If the element is not in the correct order, the elements are swapped. The swapping process continues until all the elements are placed in the correct position.
2) Deletion:  As you know that in a max heap, the maximum element is the root node. And it will remove the element which has maximum priority first. Thus, you remove the root node from the queue. This removal creates an empty slot, which will be further filled with new insertion. Then, it compares the newly inserted element with all the elements inside the queue to maintain the heap invariant.
3) Peek: This operation helps to return the maximum element from Max Heap or minimum element from Min Heap without deleting the node from the priority queue.
1) Ascending Order: As the name suggests, in ascending order priority queue, the element with a lower priority value is given a higher priority in the priority list. For example, if we have the following elements in a priority queue arranged in ascending order like 4,6,8,9,10. Here, 4 is the smallest number, therefore, it will get the highest priority in a priority queue.
2) Descending order: The root node is the maximum element in a max heap, as you may know. It will also remove the element with the highest priority first. As a result, the root node is removed from the queue. This deletion leaves an empty space, which will be filled with fresh insertions in the future. The heap invariant is then maintained by comparing the newly inserted element to all other entries in the queue.
Priority queue can be implemented using the following data structures: 
Arrays
Linked list
Heap data structure
Binary search tree
Let’s discuss all these in detail.1) Using Array: A simple implementation is to use an array of the following structure. 
struct item {
   int item;
   int priority;
}
enqueue(): This function is used to insert new data into the queue.
dequeue(): This function removes the element with the highest priority from the queue.
peek()/top(): This function is used to get the highest priority element in the queue without removing it from the queue.
Arrays
enqueue()
dequeue()
peek()
Time Complexity
O(1)
O(n)
O(n)
C++
// C++ program to implement Priority Queue// using Arrays#include <bits/stdc++.h>using namespace std; // Structure for the elements in the// priority queuestruct item {    int value;    int priority;}; // Store the element of a priority queueitem pr[100000]; // Pointer to the last indexint size = -1; // Function to insert a new element// into priority queuevoid enqueue(int value, int priority){    // Increase the size    size++;     // Insert the element    pr[size].value = value;    pr[size].priority = priority;} // Function to check the top elementint peek(){    int highestPriority = INT_MIN;    int ind = -1;     // Check for the element with    // highest priority    for (int i = 0; i <= size; i++) {         // If priority is same choose        // the element with the        // highest value        if (highestPriority == pr[i].priority && ind > -1            && pr[ind].value < pr[i].value) {            highestPriority = pr[i].priority;            ind = i;        }        else if (highestPriority < pr[i].priority) {            highestPriority = pr[i].priority;            ind = i;        }    }     // Return position of the element    return ind;} // Function to remove the element with// the highest priorityvoid dequeue(){    // Find the position of the element    // with highest priority    int ind = peek();     // Shift the element one index before    // from the position of the element    // with highest priority is found    for (int i = ind; i < size; i++) {        pr[i] = pr[i + 1];    }     // Decrease the size of the    // priority queue by one    size--;} // Driver Codeint main(){    // Function Call to insert elements    // as per the priority    enqueue(10, 2);    enqueue(14, 4);    enqueue(16, 4);    enqueue(12, 3);     // Stores the top element    // at the moment    int ind = peek();     cout << pr[ind].value << endl;     // Dequeue the top element    dequeue();     // Check the top element    ind = peek();    cout << pr[ind].value << endl;     // Dequeue the top element    dequeue();     // Check the top element    ind = peek();    cout << pr[ind].value << endl;     return 0;}
16
14
12
Note: Read this article for more details.
2) Using Linked List: In a LinkedList implementation, the entries are sorted in descending order based on their priority. The highest priority element is always added to the front of the priority queue, which is formed using linked lists. The functions like push(), pop(), and peek() are used to implement priority queue using a linked list and are explained as follows:
push(): This function is used to insert new data into the queue.
pop(): This function removes the element with the highest priority from the queue.
peek() / top(): This function is used to get the highest priority element in the queue without removing it from the queue.
Linked List
push()
pop()
peek()
Time Complexity
 O(n)   
 O(1)  
O(1)
C++
// C++ code to implement Priority Queue// using Linked List#include <bits/stdc++.h>using namespace std; // Nodetypedef struct node {    int data;     // Lower values indicate    // higher priority    int priority;     struct node* next; } Node; // Function to create a new nodeNode* newNode(int d, int p){    Node* temp = (Node*)malloc(sizeof(Node));    temp->data = d;    temp->priority = p;    temp->next = NULL;     return temp;} // Return the value at headint peek(Node** head) { return (*head)->data; } // Removes the element with the// highest priority form the listvoid pop(Node** head){    Node* temp = *head;    (*head) = (*head)->next;    free(temp);} // Function to push according to priorityvoid push(Node** head, int d, int p){    Node* start = (*head);     // Create new Node    Node* temp = newNode(d, p);     // Special Case: The head of list has    // lesser priority than new node    if ((*head)->priority > p) {         // Insert New Node before head        temp->next = *head;        (*head) = temp;    }    else {         // Traverse the list and find a        // position to insert new node        while (start->next != NULL               && start->next->priority < p) {            start = start->next;        }         // Either at the ends of the list        // or at required position        temp->next = start->next;        start->next = temp;    }} // Function to check is list is emptyint isEmpty(Node** head) { return (*head) == NULL; } // Driver codeint main(){     // Create a Priority Queue    // 7->4->5->6    Node* pq = newNode(4, 1);    push(&pq, 5, 2);    push(&pq, 6, 3);    push(&pq, 7, 0);     while (!isEmpty(&pq)) {        cout << " " << peek(&pq);        pop(&pq);    }    return 0;}
 7 4 5 6
Refer to this article for more details.
Note: We can also use Linked List, time complexity of all operations with linked list remains same as array. The advantage with linked list is deleteHighestPriority() can be more efficient as we don’t have to move items. 
3) Using Heaps: Binary Heap is generally preferred for priority queue implementation because heaps provide better performance compared to arrays or LinkedList. Operation on Binary Heap are as follows: 
insert(p): Inserts a new element with priority p.
extractMax(): Extracts an element with maximum priority.
remove(i): Removes an element pointed by an iterator i.
getMax(): Returns an element with maximum priority.
changePriority(i, p): Changes the priority of an element pointed by i to p.
Binary Heap
insert()
remove()
peek()
Time Complexity
O(log n)
O(log n)
O(1)
Refer to this article for code implementation. 
4) Using Binary Search Tree: A Self-Balancing Binary Search Tree like AVL Tree, Red-Black Tree, etc. can also be used to implement a priority queue. Operations like peek(), insert() and delete() can be performed using BST.
What is the difference between Priority Queue and Normal Queue?
There is no priority attached to elements in a queue, the rule of first-in-first-out(FIFO) is implemented whereas, in a priority queue, the elements have a priority. The elements with higher priority are served first.
Applications of Priority Queue: 
CPU Scheduling
Graph algorithms like Dijkstra’s shortest path algorithm, Prim’s Minimum Spanning Tree, etc.
Stack Implementation
All queue applications where priority is involved.
Data compression in Huffman code
See also: 
Recent articles on Priority Queue!Applications of Priority Queue.Priority Queue in C++.Priority Queue in Java.Priority Queue in Python.Priority Queue in JavaScript.
Recent articles on Priority Queue!
Applications of Priority Queue.
Priority Queue in C++.
Priority Queue in Java.
Priority Queue in Python.
Priority Queue in JavaScript.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
anshikajain26
as5853535
priority-queue
Queue
Queue
priority-queue
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Level Order Binary Tree Traversal
Queue Interface In Java
Queue in Python
Circular Queue | Set 1 (Introduction and Array Implementation)
Sliding Window Maximum (Maximum of all subarrays of size k)
Array implementation of queue (Simple)
Difference between Stack and Queue Data Structures
Priority Queue in Python
Program for Page Replacement Algorithms | Set 2 (FIFO)
Print Nodes in Top View of Binary Tree