- Data Structures & Algorithms
- DSA - Home
- DSA - Introduction
- DSA - Environment Setup
- DSA - Algorithms Basics
- DSA - Characteristics of Algorithms
- DSA - Asymptotic Analysis
- Data Structures
- DSA - Data Structure Basics
- DSA - Data Structures and Types
- DSA - Array Data Structure
- Linked Lists
- DSA - Linked List Data Structure
- DSA - Single Linked List Data Structure
- DSA - Doubly Linked List Data Structure
- DSA - Circular Linked List Data Structure
- Stack & Queue
- DSA - Stack Data Structure
- DSA - Expression Parsing
- DSA - Queue Data Structure
- Searching Algorithms
- DSA - Searching Algorithms
- DSA - Linear Search Algorithm
- DSA - Binary Search Algorithm
- DSA - Interpolation Search
- DSA - Jump Search Algorithm
- DSA - Exponential Search
- DSA - Fibonacci Search
- DSA - Sublist Search
- DSA - Hash Table
- Sorting Algorithms
- DSA - Sorting Algorithms
- DSA - Bubble Sort Algorithm
- DSA - Insertion Sort Algorithm
- DSA - Selection Sort Algorithm
- DSA - Merge Sort Algorithm
- DSA - Shell Sort Algorithm
- DSA - Heap Sort
- DSA - Bucket Sort Algorithm
- DSA - Counting Sort Algorithm
- DSA - Radix Sort Algorithm
- DSA - Quick Sort Algorithm
- Graph Data Structure
- DSA - Graph Data Structure
- DSA - Depth First Traversal
- DSA - Breadth First Traversal
- DSA - Spanning Tree
- Tree Data Structure
- DSA - Tree Data Structure
- DSA - Tree Traversal
- DSA - Binary Search Tree
- DSA - AVL Tree
- DSA - Red Black Trees
- DSA - B Trees
- DSA - B+ Trees
- DSA - Splay Trees
- DSA - Tries
- DSA - Heap Data Structure
- Recursion
- DSA - Recursion Algorithms
- DSA - Tower of Hanoi Using Recursion
- DSA - Fibonacci Series Using Recursion
- Divide and Conquer
- DSA - Divide and Conquer
- DSA - Max-Min Problem
- DSA - Strassen's Matrix Multiplication
- DSA - Karatsuba Algorithm
- Greedy Algorithms
- DSA - Greedy Algorithms
- DSA - Travelling Salesman Problem (Greedy Approach)
- DSA - Prim's Minimal Spanning Tree
- DSA - Kruskal's Minimal Spanning Tree
- DSA - Dijkstra's Shortest Path Algorithm
- DSA - Map Colouring Algorithm
- DSA - Fractional Knapsack Problem
- DSA - Job Sequencing with Deadline
- DSA - Optimal Merge Pattern Algorithm
- Dynamic Programming
- DSA - Dynamic Programming
- DSA - Matrix Chain Multiplication
- DSA - Floyd Warshall Algorithm
- DSA - 0-1 Knapsack Problem
- DSA - Longest Common Subsequence Algorithm
- DSA - Travelling Salesman Problem (Dynamic Approach)
- Approximation Algorithms
- DSA - Approximation Algorithms
- DSA - Vertex Cover Algorithm
- DSA - Set Cover Problem
- DSA - Travelling Salesman Problem (Approximation Approach)
- Randomized Algorithms
- DSA - Randomized Algorithms
- DSA - Randomized Quick Sort Algorithm
- DSA - Karger’s Minimum Cut Algorithm
- DSA - Fisher-Yates Shuffle Algorithm
Data Structures & Algorithms - Queue Algorithm
 Share with a Friend |
Queue Algorithm
A Queue is a linear data structure that follows the FIFO (First In, First Out) principle. The element inserted first is the one to be removed first.
🔹 Basic Operations in Queue
- Enqueue – Insert an element at the rear.
- Dequeue – Remove an element from the front.
- Front (Peek) – Get the front element.
- isEmpty – Check if the queue is empty.
- isFull – (For static queue) Check if the queue is full.
🔹 Real-World Examples
- Ticketing systems
- Printer queue
- Call center phone lines
- OS scheduling (e.g., Round Robin)
✅ Queue Implementation using Array - C, C++, Java, Python
#include <stdio.h>
#define SIZE 5
int queue[SIZE];
int front = -1, rear = -1;
void enqueue(int val) {
if (rear == SIZE - 1) {
printf("Queue Overflow\n");
return;
}
if (front == -1) front = 0;
queue[++rear] = val;
}
void dequeue() {
if (front == -1 || front > rear) {
printf("Queue Underflow\n");
return;
}
printf("Dequeued: %d\n", queue[front++]);
}
void display() {
if (front == -1 || front > rear) {
printf("Queue is empty\n");
return;
}
printf("Queue: ");
for (int i = front; i <= rear; i++)
printf("%d ", queue[i]);
printf("\n");
}
int main() {
enqueue(10); enqueue(20); enqueue(30);
display();
dequeue();
display();
return 0;
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
#include <iostream>
#define SIZE 5
using namespace std;
class Queue {
int arr[SIZE];
int front, rear;
public:
Queue() {
front = -1;
rear = -1;
}
void enqueue(int val) {
if (rear == SIZE - 1) {
cout << "Queue Overflow\n";
return;
}
if (front == -1) front = 0;
arr[++rear] = val;
}
void dequeue() {
if (front == -1 || front > rear) {
cout << "Queue Underflow\n";
return;
}
cout << "Dequeued: " << arr[front++] << endl;
}
void display() {
if (front == -1 || front > rear) {
cout << "Queue is empty\n";
return;
}
cout << "Queue: ";
for (int i = front; i <= rear; i++)
cout << arr[i] << " ";
cout << endl;
}
};
int main() {
Queue q;
q.enqueue(10); q.enqueue(20); q.enqueue(30);
q.display();
q.dequeue();
q.display();
return 0;
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
public class ArrayQueue {
static final int SIZE = 5;
int[] queue = new int[SIZE];
int front = -1, rear = -1;
void enqueue(int val) {
if (rear == SIZE - 1) {
System.out.println("Queue Overflow");
return;
}
if (front == -1) front = 0;
queue[++rear] = val;
}
void dequeue() {
if (front == -1 || front > rear) {
System.out.println("Queue Underflow");
return;
}
System.out.println("Dequeued: " + queue[front++]);
}
void display() {
if (front == -1 || front > rear) {
System.out.println("Queue is empty");
return;
}
System.out.print("Queue: ");
for (int i = front; i <= rear; i++)
System.out.print(queue[i] + " ");
System.out.println();
}
public static void main(String[] args) {
ArrayQueue q = new ArrayQueue();
q.enqueue(10); q.enqueue(20); q.enqueue(30);
q.display();
q.dequeue();
q.display();
}
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
SIZE = 5
queue = [None] * SIZE
front = -1
rear = -1
def enqueue(val):
global rear, front
if rear == SIZE - 1:
print("Queue Overflow")
return
if front == -1:
front = 0
rear += 1
queue[rear] = val
def dequeue():
global front
if front == -1 or front > rear:
print("Queue Underflow")
return
print("Dequeued:", queue[front])
front += 1
def display():
if front == -1 or front > rear:
print("Queue is empty")
else:
print("Queue:", queue[front:rear+1])
# Test
enqueue(10)
enqueue(20)
enqueue(30)
display()
dequeue()
display()
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
✅ Queue Implementation using Linked List - C, C++, Java, Python
Queue Implementation using Linked List in C, C++, Java, and Python, including the key operations: enqueue, dequeue, and display.
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node *front = NULL, *rear = NULL;
void enqueue(int val) {
struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
temp->data = val;
temp->next = NULL;
if (rear == NULL) {
front = rear = temp;
return;
}
rear->next = temp;
rear = temp;
}
void dequeue() {
if (front == NULL) {
printf("Queue Underflow\n");
return;
}
struct Node* temp = front;
front = front->next;
if (front == NULL) rear = NULL;
printf("Dequeued: %d\n", temp->data);
free(temp);
}
void display() {
struct Node* temp = front;
if (!temp) {
printf("Queue is empty\n");
return;
}
printf("Queue: ");
while (temp) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
int main() {
enqueue(10);
enqueue(20);
enqueue(30);
display();
dequeue();
display();
return 0;
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
class Queue {
Node *front, *rear;
public:
Queue() {
front = rear = nullptr;
}
void enqueue(int val) {
Node* temp = new Node{val, nullptr};
if (!rear) {
front = rear = temp;
return;
}
rear->next = temp;
rear = temp;
}
void dequeue() {
if (!front) {
cout << "Queue Underflow\n";
return;
}
Node* temp = front;
front = front->next;
if (!front) rear = nullptr;
cout << "Dequeued: " << temp->data << endl;
delete temp;
}
void display() {
if (!front) {
cout << "Queue is empty\n";
return;
}
Node* temp = front;
cout << "Queue: ";
while (temp) {
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
};
int main() {
Queue q;
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.display();
q.dequeue();
q.display();
return 0;
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
class Node {
int data;
Node next;
Node(int d) {
data = d;
next = null;
}
}
class Queue {
Node front, rear;
public void enqueue(int val) {
Node temp = new Node(val);
if (rear == null) {
front = rear = temp;
return;
}
rear.next = temp;
rear = temp;
}
public void dequeue() {
if (front == null) {
System.out.println("Queue Underflow");
return;
}
System.out.println("Dequeued: " + front.data);
front = front.next;
if (front == null) rear = null;
}
public void display() {
if (front == null) {
System.out.println("Queue is empty");
return;
}
System.out.print("Queue: ");
Node temp = front;
while (temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
System.out.println();
}
public static void main(String[] args) {
Queue q = new Queue();
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.display();
q.dequeue();
q.display();
}
}
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
class Node:
def __init__(self, data):
self.data = data
self.next = None
class Queue:
def __init__(self):
self.front = self.rear = None
def enqueue(self, val):
temp = Node(val)
if self.rear is None:
self.front = self.rear = temp
return
self.rear.next = temp
self.rear = temp
def dequeue(self):
if self.front is None:
print("Queue Underflow")
return
print("Dequeued:", self.front.data)
self.front = self.front.next
if self.front is None:
self.rear = None
def display(self):
if self.front is None:
print("Queue is empty")
return
temp = self.front
print("Queue:", end=" ")
while temp:
print(temp.data, end=" ")
temp = temp.next
print()
# Test
q = Queue()
q.enqueue(10)
q.enqueue(20)
q.enqueue(30)
q.display()
q.dequeue()
q.display()
Output
Queue: 10 20 30
Dequeued: 10
Queue: 20 30
✅ Circular Queue Implementation - C, C++, Java, Python
#include <stdio.h>
#define SIZE 5
int queue[SIZE];
int front = -1, rear = -1;
void enqueue(int value) {
if ((rear + 1) % SIZE == front) {
printf("Queue is Full\n");
} else {
if (front == -1) front = 0;
rear = (rear + 1) % SIZE;
queue[rear] = value;
printf("Inserted %d\n", value);
}
}
void dequeue() {
if (front == -1) {
printf("Queue is Empty\n");
} else {
printf("Deleted: %d\n", queue[front]);
if (front == rear) front = rear = -1;
else front = (front + 1) % SIZE;
}
}
void display() {
if (front == -1) {
printf("Queue is Empty\n");
return;
}
int i = front;
printf("Queue: ");
while (1) {
printf("%d ", queue[i]);
if (i == rear) break;
i = (i + 1) % SIZE;
}
printf("\n");
}
int main() {
enqueue(10); enqueue(20); enqueue(30);
display();
dequeue(); dequeue();
display();
enqueue(40); enqueue(50); enqueue(60);
display();
return 0;
}
Output
Inserted: 10 Inserted: 20 Inserted: 30 Queue: 10 20 30 Deleted: 10 Deleted: 20 Queue: 30 Inserted: 40 Inserted: 50 Inserted: 60 Queue: 30 40 50 60
//C++ Program – Circular Queue using Array
#include <iostream>
#define SIZE 5
using namespace std;
class CircularQueue {
int queue[SIZE], front = -1, rear = -1;
public:
void enqueue(int value) {
if ((rear + 1) % SIZE == front) {
cout << "Queue is Full\n";
} else {
if (front == -1) front = 0;
rear = (rear + 1) % SIZE;
queue[rear] = value;
cout << "Inserted: " << value << endl;
}
}
void dequeue() {
if (front == -1) {
cout << "Queue is Empty\n";
} else {
cout << "Deleted: " << queue[front] << endl;
if (front == rear) front = rear = -1;
else front = (front + 1) % SIZE;
}
}
void display() {
if (front == -1) {
cout << "Queue is Empty\n";
return;
}
int i = front;
cout << "Queue: ";
while (true) {
cout << queue[i] << " ";
if (i == rear) break;
i = (i + 1) % SIZE;
}
cout << endl;
}
};
int main() {
CircularQueue q;
q.enqueue(10); q.enqueue(20); q.enqueue(30);
q.display();
q.dequeue(); q.dequeue();
q.display();
q.enqueue(40); q.enqueue(50); q.enqueue(60);
q.display();
return 0;
}
Output
Inserted: 10 Inserted: 20 Inserted: 30 Queue: 10 20 30 Deleted: 10 Deleted: 20 Queue: 30 Inserted: 40 Inserted: 50 Inserted: 60 Queue: 30 40 50 60
// Java Program – Circular Queue using Array
class CircularQueue {
int SIZE = 5;
int[] queue = new int[SIZE];
int front = -1, rear = -1;
void enqueue(int value) {
if ((rear + 1) % SIZE == front) {
System.out.println("Queue is Full");
} else {
if (front == -1) front = 0;
rear = (rear + 1) % SIZE;
queue[rear] = value;
System.out.println("Inserted: " + value);
}
}
void dequeue() {
if (front == -1) {
System.out.println("Queue is Empty");
} else {
System.out.println("Deleted: " + queue[front]);
if (front == rear) front = rear = -1;
else front = (front + 1) % SIZE;
}
}
void display() {
if (front == -1) {
System.out.println("Queue is Empty");
return;
}
int i = front;
System.out.print("Queue: ");
while (true) {
System.out.print(queue[i] + " ");
if (i == rear) break;
i = (i + 1) % SIZE;
}
System.out.println();
}
public static void main(String[] args) {
CircularQueue q = new CircularQueue();
q.enqueue(10); q.enqueue(20); q.enqueue(30);
q.display();
q.dequeue(); q.dequeue();
q.display();
q.enqueue(40); q.enqueue(50); q.enqueue(60);
q.display();
}
}
Output
Inserted: 10 Inserted: 20 Inserted: 30 Queue: 10 20 30 Deleted: 10 Deleted: 20 Queue: 30 Inserted: 40 Inserted: 50 Inserted: 60 Queue: 30 40 50 60
# Python Program – Circular Queue using List
class CircularQueue:
def __init__(self, size):
self.size = size
self.queue = [None]*size
self.front = self.rear = -1
def enqueue(self, value):
if (self.rear + 1) % self.size == self.front:
print("Queue is Full")
else:
if self.front == -1:
self.front = 0
self.rear = (self.rear + 1) % self.size
self.queue[self.rear] = value
print(f"Inserted: {value}")
def dequeue(self):
if self.front == -1:
print("Queue is Empty")
else:
print(f"Deleted: {self.queue[self.front]}")
if self.front == self.rear:
self.front = self.rear = -1
else:
self.front = (self.front + 1) % self.size
def display(self):
if self.front == -1:
print("Queue is Empty")
return
i = self.front
print("Queue:", end=" ")
while True:
print(self.queue[i], end=" ")
if i == self.rear:
break
i = (i + 1) % self.size
print()
# Usage
q = CircularQueue(5)
q.enqueue(10)
q.enqueue(20)
q.enqueue(30)
q.display()
q.dequeue()
q.dequeue()
q.display()
q.enqueue(40)
q.enqueue(50)
q.enqueue(60)
q.display()
Output
Inserted: 10 Inserted: 20 Inserted: 30 Queue: 10 20 30 Deleted: 10 Deleted: 20 Queue: 30 Inserted: 40 Inserted: 50 Inserted: 60 Queue: 30 40 50 60
✅ Priority Queue Implementation - C, C++, Java, Python
Using Array
#include <stdio.h>
#define MAX 100
typedef struct {
int data[MAX];
int priority[MAX];
int size;
} PriorityQueue;
void init(PriorityQueue* pq) {
pq->size = 0;
}
void enqueue(PriorityQueue* pq, int value, int prio) {
if (pq->size == MAX) {
printf("Queue is full\n");
return;
}
int i = pq->size - 1;
// Insert based on priority (lower number = higher priority)
while (i >= 0 && pq->priority[i] > prio) {
pq->priority[i + 1] = pq->priority[i];
pq->data[i + 1] = pq->data[i];
i--;
}
pq->priority[i + 1] = prio;
pq->data[i + 1] = value;
pq->size++;
}
int dequeue(PriorityQueue* pq) {
if (pq->size == 0) {
printf("Queue is empty\n");
return -1;
}
int val = pq->data[0];
// Shift elements left
for (int i = 1; i < pq->size; i++) {
pq->data[i-1] = pq->data[i];
pq->priority[i-1] = pq->priority[i];
}
pq->size--;
return val;
}
void display(PriorityQueue* pq) {
printf("Priority Queue: \n");
for (int i = 0; i < pq->size; i++) {
printf("Value: %d Priority: %d\n", pq->data[i], pq->priority[i]);
}
}
int main() {
PriorityQueue pq;
init(&pq);
enqueue(&pq, 40, 2);
enqueue(&pq, 50, 1);
enqueue(&pq, 60, 3);
display(&pq);
printf("Dequeued element: %d\n", dequeue(&pq));
display(&pq);
return 0;
}
Output
Priority Queue:
Value: 50 Priority: 1
Value: 40 Priority: 2
Value: 60 Priority: 3
Dequeued element: 50
Priority Queue:
Value: 40 Priority: 2
Value: 60 Priority: 3
#include <iostream>
using namespace std;
class PriorityQueue {
int data[100];
int priority[100];
int size;
public:
PriorityQueue() { size = 0; }
void enqueue(int val, int prio) {
if (size == 100) {
cout << "Queue full\n";
return;
}
int i = size - 1;
while (i >= 0 && priority[i] > prio) {
priority[i + 1] = priority[i];
data[i + 1] = data[i];
i--;
}
priority[i + 1] = prio;
data[i + 1] = val;
size++;
}
int dequeue() {
if (size == 0) {
cout << "Queue empty\n";
return -1;
}
int val = data[0];
for (int i = 1; i < size; i++) {
data[i - 1] = data[i];
priority[i - 1] = priority[i];
}
size--;
return val;
}
void display() {
cout << "Priority Queue:\n";
for (int i = 0; i < size; i++) {
cout << "Value: " << data[i] << " Priority: " << priority[i] << endl;
}
}
};
int main() {
PriorityQueue pq;
pq.enqueue(40, 2);
pq.enqueue(50, 1);
pq.enqueue(60, 3);
pq.display();
cout << "Dequeued element: " << pq.dequeue() << endl;
pq.display();
return 0;
}
Output
Priority Queue:
Value: 50 Priority: 1
Value: 40 Priority: 2
Value: 60 Priority: 3
Dequeued element: 50
Priority Queue:
Value: 40 Priority: 2
Value: 60 Priority: 3
public class PriorityQueueArray {
private int[] data;
private int[] priority;
private int size;
private int capacity;
public PriorityQueueArray(int capacity) {
this.capacity = capacity;
data = new int[capacity];
priority = new int[capacity];
size = 0;
}
public void enqueue(int val, int prio) {
if (size == capacity) {
System.out.println("Queue full");
return;
}
int i = size - 1;
while (i >= 0 && priority[i] > prio) {
priority[i + 1] = priority[i];
data[i + 1] = data[i];
i--;
}
priority[i + 1] = prio;
data[i + 1] = val;
size++;
}
public int dequeue() {
if (size == 0) {
System.out.println("Queue empty");
return -1;
}
int val = data[0];
for (int i = 1; i < size; i++) {
data[i - 1] = data[i];
priority[i - 1] = priority[i];
}
size--;
return val;
}
public void display() {
System.out.println("Priority Queue:");
for (int i = 0; i < size; i++) {
System.out.println("Value: " + data[i] + " Priority: " + priority[i]);
}
}
public static void main(String[] args) {
PriorityQueueArray pq = new PriorityQueueArray(10);
pq.enqueue(40, 2);
pq.enqueue(50, 1);
pq.enqueue(60, 3);
pq.display();
System.out.println("Dequeued element: " + pq.dequeue());
pq.display();
}
}
Output
Priority Queue:
Value: 50 Priority: 1
Value: 40 Priority: 2
Value: 60 Priority: 3
Dequeued element: 50
Priority Queue:
Value: 40 Priority: 2
Value: 60 Priority: 3
class PriorityQueue:
def __init__(self):
self.data = []
self.priority = []
def enqueue(self, val, prio):
i = len(self.priority) - 1
self.priority.append(0) # dummy append
self.data.append(0)
while i >= 0 and self.priority[i] > prio:
self.priority[i + 1] = self.priority[i]
self.data[i + 1] = self.data[i]
i -= 1
self.priority[i + 1] = prio
self.data[i + 1] = val
def dequeue(self):
if len(self.data) == 0:
print("Queue is empty")
return None
val = self.data.pop(0)
self.priority.pop(0)
return val
def display(self):
print("Priority Queue:")
for v, p in zip(self.data, self.priority):
print(f"Value: {v} Priority: {p}")
pq = PriorityQueue()
pq.enqueue(40, 2)
pq.enqueue(50, 1)
pq.enqueue(60, 3)
pq.display()
print("Dequeued element:", pq.dequeue())
pq.display()
Output
Priority Queue:
Value: 50 Priority: 1
Value: 40 Priority: 2
Value: 60 Priority: 3
Dequeued element: 50
Priority Queue:
Value: 40 Priority: 2
Value: 60 Priority: 3
Priority Queue using Linked List
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
int priority;
struct Node* next;
};
struct Node* front = NULL;
void enqueue(int d, int p) {
struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
temp->data = d;
temp->priority = p;
temp->next = NULL;
if (!front || p < front->priority) {
temp->next = front;
front = temp;
} else {
struct Node* start = front;
while (start->next && start->next->priority <= p)
start = start->next;
temp->next = start->next;
start->next = temp;
}
}
void dequeue() {
if (!front) {
printf("Queue is empty\n");
return;
}
struct Node* temp = front;
front = front->next;
printf("Dequeued element: %d\n", temp->data);
free(temp);
}
void display() {
struct Node* temp = front;
printf("Priority Queue:\n");
while (temp) {
printf("Value: %d Priority: %d\n", temp->data, temp->priority);
temp = temp->next;
}
}
Output
Priority Queue: Value: 50 Priority: 1 Value: 40 Priority: 2 Value: 60 Priority: 3 Dequeued element: 50 Priority Queue: Value: 40 Priority: 2 Value: 60 Priority: 3
#include <iostream>
using namespace std;
struct Node {
int data, priority;
Node* next;
};
Node* front = nullptr;
void enqueue(int d, int p) {
Node* temp = new Node{d, p, nullptr};
if (!front || p < front->priority) {
temp->next = front;
front = temp;
} else {
Node* start = front;
while (start->next && start->next->priority <= p)
start = start->next;
temp->next = start->next;
start->next = temp;
}
}
void dequeue() {
if (!front) {
cout << "Queue is empty\n";
return;
}
Node* temp = front;
front = front->next;
cout << "Dequeued element: " << temp->data << endl;
delete temp;
}
void display() {
Node* temp = front;
cout << "Priority Queue:\n";
while (temp) {
cout << "Value: " << temp->data << " Priority: " << temp->priority << endl;
temp = temp->next;
}
}
Output
Priority Queue: Value: 50 Priority: 1 Value: 40 Priority: 2 Value: 60 Priority: 3 Dequeued element: 50 Priority Queue: Value: 40 Priority: 2 Value: 60 Priority: 3
class Node {
int data, priority;
Node next;
public Node(int data, int priority) {
this.data = data;
this.priority = priority;
this.next = null;
}
}
public class PriorityQueueLinkedList {
static Node front = null;
static void enqueue(int data, int priority) {
Node temp = new Node(data, priority);
if (front == null || priority < front.priority) {
temp.next = front;
front = temp;
} else {
Node start = front;
while (start.next != null && start.next.priority <= priority)
start = start.next;
temp.next = start.next;
start.next = temp;
}
}
static void dequeue() {
if (front == null) {
System.out.println("Queue is empty");
return;
}
System.out.println("Dequeued element: " + front.data);
front = front.next;
}
static void display() {
Node temp = front;
System.out.println("Priority Queue:");
while (temp != null) {
System.out.println("Value: " + temp.data + " Priority: " + temp.priority);
temp = temp.next;
}
}
public static void main(String[] args) {
enqueue(40, 2);
enqueue(50, 1);
enqueue(60, 3);
display();
dequeue();
display();
}
}
Output
Priority Queue: Value: 50 Priority: 1 Value: 40 Priority: 2 Value: 60 Priority: 3 Dequeued element: 50 Priority Queue: Value: 40 Priority: 2 Value: 60 Priority: 3
class Node:
def __init__(self, data, priority):
self.data = data
self.priority = priority
self.next = None
class PriorityQueue:
def __init__(self):
self.front = None
def enqueue(self, data, priority):
new_node = Node(data, priority)
if not self.front or priority < self.front.priority:
new_node.next = self.front
self.front = new_node
else:
temp = self.front
while temp.next and temp.next.priority <= priority:
temp = temp.next
new_node.next = temp.next
temp.next = new_node
def dequeue(self):
if not self.front:
print("Queue is empty")
return
print(f"Dequeued element: {self.front.data}")
self.front = self.front.next
def display(self):
temp = self.front
print("Priority Queue:")
while temp:
print(f"Value: {temp.data} Priority: {temp.priority}")
temp = temp.next
# Example usage
pq = PriorityQueue()
pq.enqueue(40, 2)
pq.enqueue(50, 1)
pq.enqueue(60, 3)
pq.display()
pq.dequeue()
pq.display()
Output
Priority Queue: Value: 50 Priority: 1 Value: 40 Priority: 2 Value: 60 Priority: 3 Dequeued element: 50 Priority Queue: Value: 40 Priority: 2 Value: 60 Priority: 3
🔁 Queue-Based Real-World Applications
1. Print Queue
- Scenario: When multiple documents are sent to a printer, they are queued and printed one by one.
- Why Queue: Ensures First-In-First-Out (FIFO)
2. Task Scheduling in Operating Systems
- Scenario: Processes waiting for CPU time are managed in ready queues, I/O queues, etc.
- Why Queue: Ensures fair allocation of CPU to processes.
3. Customer Service Systems
- Scenario: Calls or chat requests are placed in a queue to be handled by the next available agent.
- Why Queue: Helps maintain service order and fairness.
4. Breadth-First Search (BFS) in Graph Algorithms
- Scenario: Used in shortest path problems, peer-to-peer networks, etc.
- Why Queue: BFS uses a queue to explore nodes level by level.
5. Data Buffers (IO Buffers, Network Routers)
- Scenario: Buffers hold data temporarily while it's being moved from one place to another.
- Why Queue: Helps in smooth data transmission when producer-consumer rates differ.
6. Order Processing Systems (E-commerce)
- Scenario: Orders placed are queued and processed in the order they were received.
- Why Queue: Maintains transaction integrity and order.
7. Message Queues in Distributed Systems
- Scenario: Systems like RabbitMQ, Kafka use queues for decoupled communication between microservices.
- Why Queue: Ensures reliable and scalable communication.
8. Traffic Management Systems
- Scenario: Vehicles at a traffic signal or toll booth are queued.
- Why Queue: Helps manage congestion and flow.
9. Call Center Hold Queue
- Scenario: When all representatives are busy, incoming calls are placed in a queue.
- Why Queue: Preserves the order in which users requested service.
10. Ticket Booking Systems
- Scenario: Railway, airline, or cinema booking systems use queues when demand is high.
- Why Queue: Ensures fairness in ticket allotment.