# Priority Queue In this tutorial, you will learn what a priority queue is. Likewise, you will learn about its implementations in Python, Java, C, and C++.

A priority queue is a special sort of queue wherein each element is associated with a priority and is served by its priority. In the event that elements with a similar priority happen, they are served by their request in the queue.

For the most part, the value of the element itself is considered for assigning the priority.

For instance, The element with the highest worth is considered as the highest priority element. Be that as it may, in different cases, we can assume the element with the lowest value as the highest priority element. In different cases, we can set priorities as indicated by our necessities.

Contents

## What is a priority queue?

A priority queue is an abstract data type that carries on comparatively to the normal queue aside from that each element has some priority, i.e., the element with the highest priority would come first in a priority queue. The priority of the elements in a priority queue will decide the request wherein elements are eliminated from the priority queue.

The priority queue supports just comparable elements, which implies that the elements are either arranged in an ascending or descending order.

For instance, assume we have a few values like 1, 3, 4, 8, 14, 22 inserted in a priority queue with an ordering imposed on the values is from least to the greatest. In this manner, the 1 number would have the highest priority while 22 will have the lowest priority.

## Difference between Priority Queue and Normal Queue

In a queue, the first-in-first-out rule is executed while, in a priority queu, the values are eliminated on the basis of priority. The element with the highest priority is eliminated first.

## Implementation of Priority Queue

Priority queue can be actualized using an array, a connected rundown, a pile data structure, or a binary search tree. Among these data structures, heap data structure provides a proficient usage of priority queues.

Thus, we will use the pile data structure to actualize the priority queue in this tutorial. A max-heap is implemented is in the accompanying activities.

A comparative analysis of different implementations of priority queue is given below.

## 1. Inserting an Element into the Priority Queues

Inserting an element into a priority queu (max-heap) is finished by the accompanying steps.

• Insert the new element toward the finish of the tree.
• Heapify the tree.

Algorithm for insertion of an element into priority queue (max-heap)

```If there is no node,
create a newNode.
else (a node is already present)
insert the newNode at the end (last node from left to right.)

heapify the array```

For Min Heap, the above algorithm is modified so that parentNode is always smaller than newNode.

## 2. Deleting an Element from the Priority Queues

Erasing an element from a priority queue (max-store) is done as follows:

• Select the element to be erased.
• Swap it with the last element.
• Remove the last element.
• Heapify the tree.

Algorithm for deletion of an element in the priority queue (max-heap)

```If nodeToBeDeleted is the leafNode
remove the node
Else swap nodeToBeDeleted with the lastLeafNode
remove noteToBeDeleted

heapify the array```

For Min Heap, the above algorithm is modified so that the both childNodes are smaller than currentNode.

## 3. Peeking from the Priority Queues (Find max/min)

Peek activity returns the maximum element from Max Heap or minimum element from Min Heap without erasing the node.

For both Max heap and Min Heap

`return rootNode`

## 4. Extract Max/Min from the Priority Queues

Extract Max returns the node with maximum value subsequent to eliminating it from a Max Heap though Extract-Min returns the node with minimum value in the wake of eliminating it from Min Heap.

## Priority Queue Implementations in Python, Java, C, and C++

Python

```# Priority Queue implementation in Python

# Function to heapify the tree
def heapify(arr, n, i):
# Find the largest among root, left child and right child
largest = i
l = 2 * i + 1
r = 2 * i + 2

if l < n and arr[i] < arr[l]:
largest = l

if r < n and arr[largest] < arr[r]:
largest = r

# Swap and continue heapifying if root is not largest
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)

# Function to insert an element into the tree
def insert(array, newNum):
size = len(array)
if size == 0:
array.append(newNum)
else:
array.append(newNum)
for i in range((size // 2) - 1, -1, -1):
heapify(array, size, i)

# Function to delete an element from the tree
def deleteNode(array, num):
size = len(array)
i = 0
for i in range(0, size):
if num == array[i]:
break

array[i], array[size - 1] = array[size - 1], array[i]

array.remove(size - 1)

for i in range((len(array) // 2) - 1, -1, -1):
heapify(array, len(array), i)

arr = []

insert(arr, 3)
insert(arr, 4)
insert(arr, 9)
insert(arr, 5)
insert(arr, 2)

print ("Max-Heap array: " + str(arr))

deleteNode(arr, 4)
print("After deleting an element: " + str(arr))
```

Java

```// Priority Queue implementation in Java

import java.util.ArrayList;

class Heap {
// Function to heapify the tree
void heapify(ArrayList<Integer> hT, int i) {
int size = hT.size();
// Find the largest among root, left child and right child
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < size && hT.get(l) > hT.get(largest))
largest = l;
if (r < size && hT.get(r) > hT.get(largest))
largest = r;

// Swap and continue heapifying if root is not largest
if (largest != i) {
int temp = hT.get(largest);
hT.set(largest, hT.get(i));
hT.set(i, temp);

heapify(hT, largest);
}
}

// Function to insert an element into the tree
void insert(ArrayList<Integer> hT, int newNum) {
int size = hT.size();
if (size == 0) {
} else {
for (int i = size / 2 - 1; i >= 0; i--) {
heapify(hT, i);
}
}
}

// Function to delete an element from the tree
void deleteNode(ArrayList<Integer> hT, int num) {
int size = hT.size();
int i;
for (i = 0; i < size; i++) {
if (num == hT.get(i))
break;
}

int temp = hT.get(i);
hT.set(i, hT.get(size - 1));
hT.set(size - 1, temp);

hT.remove(size - 1);
for (int j = size / 2 - 1; j >= 0; j--) {
heapify(hT, j);
}
}

// Print the tree
void printArray(ArrayList<Integer> array, int size) {
for (Integer i : array) {
System.out.print(i + " ");
}
System.out.println();
}

// Driver code
public static void main(String args[]) {

ArrayList<Integer> array = new ArrayList<Integer>();
int size = array.size();

Heap h = new Heap();
h.insert(array, 3);
h.insert(array, 4);
h.insert(array, 9);
h.insert(array, 5);
h.insert(array, 2);

System.out.println("Max-Heap array: ");
h.printArray(array, size);

h.deleteNode(array, 4);
System.out.println("After deleting an element: ");
h.printArray(array, size);
}
}```

C

```// Priority Queue implementation in C

#include <stdio.h>
int size = 0;
void swap(int *a, int *b) {
int temp = *b;
*b = *a;
*a = temp;
}

// Function to heapify the tree
void heapify(int array[], int size, int i) {
if (size == 1) {
printf("Single element in the heap");
} else {
// Find the largest among root, left child and right child
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < size && array[l] > array[largest])
largest = l;
if (r < size && array[r] > array[largest])
largest = r;

// Swap and continue heapifying if root is not largest
if (largest != i) {
swap(&array[i], &array[largest]);
heapify(array, size, largest);
}
}
}

// Function to insert an element into the tree
void insert(int array[], int newNum) {
if (size == 0) {
array = newNum;
size += 1;
} else {
array[size] = newNum;
size += 1;
for (int i = size / 2 - 1; i >= 0; i--) {
heapify(array, size, i);
}
}
}

// Function to delete an element from the tree
void deleteRoot(int array[], int num) {
int i;
for (i = 0; i < size; i++) {
if (num == array[i])
break;
}

swap(&array[i], &array[size - 1]);
size -= 1;
for (int i = size / 2 - 1; i >= 0; i--) {
heapify(array, size, i);
}
}

// Print the array
void printArray(int array[], int size) {
for (int i = 0; i < size; ++i)
printf("%d ", array[i]);
printf("\n");
}

// Driver code
int main() {
int array;

insert(array, 3);
insert(array, 4);
insert(array, 9);
insert(array, 5);
insert(array, 2);

printf("Max-Heap array: ");
printArray(array, size);

deleteRoot(array, 4);

printf("After deleting an element: ");

printArray(array, size);
}```

C++

```// Priority Queue implementation in C++

#include <iostream>
#include <vector>
using namespace std;

// Function to swap position of two elements
void swap(int *a, int *b) {
int temp = *b;
*b = *a;
*a = temp;
}

// Function to heapify the tree
void heapify(vector<int> &hT, int i) {
int size = hT.size();

// Find the largest among root, left child and right child
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < size && hT[l] > hT[largest])
largest = l;
if (r < size && hT[r] > hT[largest])
largest = r;

// Swap and continue heapifying if root is not largest
if (largest != i) {
swap(&hT[i], &hT[largest]);
heapify(hT, largest);
}
}

// Function to insert an element into the tree
void insert(vector<int> &hT, int newNum) {
int size = hT.size();
if (size == 0) {
hT.push_back(newNum);
} else {
hT.push_back(newNum);
for (int i = size / 2 - 1; i >= 0; i--) {
heapify(hT, i);
}
}
}

// Function to delete an element from the tree
void deleteNode(vector<int> &hT, int num) {
int size = hT.size();
int i;
for (i = 0; i < size; i++) {
if (num == hT[i])
break;
}
swap(&hT[i], &hT[size - 1]);

hT.pop_back();
for (int i = size / 2 - 1; i >= 0; i--) {
heapify(hT, i);
}
}

// Print the tree
void printArray(vector<int> &hT) {
for (int i = 0; i < hT.size(); ++i)
cout << hT[i] << " ";
cout << "\n";
}

// Driver code
int main() {
vector<int> heapTree;

insert(heapTree, 3);
insert(heapTree, 4);
insert(heapTree, 9);
insert(heapTree, 5);
insert(heapTree, 2);

cout << "Max-Heap array: ";
printArray(heapTree);

deleteNode(heapTree, 4);

cout << "After deleting an element: ";

printArray(heapTree);
}```

## Priority Queue Applications

Some of the applications of a priority queue are:

• Dijkstra’s algorithm
• for implementing stack
• for load balancing and interrupt handling in an operating system
• for data compression in Huffman code

Thanks for reading! We hope you found this tutorial helpful and we would love to hear your feedback in the Comments section below. And show us what you’ve learned by sharing your photos and creative projects with us. ### Circular Queue Data Structure ### What is the Difference Between a Router and a Modem?  