Queue
A Queue is a linear data structure that follows the FIFO (First In, First Out) principle. The first element added to the queue is the first one to be removed. 
Real-World Analogy
Imagine a line of people waiting at a movie ticket counter. The person who arrives first gets served first, and new people join at the end of the line (Rear). Core Operations
- Enqueue: Add an element to the rear of the queue.
- Dequeue: Remove and return the front element.
- Front/Peek: View the front element without removing it.
- Rear: View the last element.
Code Implementation (Array-Based)
Below is the Java code for a simple Queue .
JavaPythonCC++
class Queue {
private int maxSize;
private int[] queueArray;
private int front;
private int rear;
private int currentSize;
public Queue(int size) {
this.maxSize = size;
this.queueArray = new int[maxSize];
this.front = 0;
this.rear = -1;
this.currentSize = 0;
}
// Enqueue: Add to rear
public void enqueue(int value) {
if (isFull()) {
System.out.println("Queue is full! Cannot enqueue " + value);
return;
}
rear = (rear + 1) % maxSize; // Handles wrapping for array
queueArray[rear] = value;
currentSize++;
System.out.println("Enqueued: " + value);
}
// Dequeue: Remove from front
public int dequeue() {
if (isEmpty()) {
System.out.println("Queue is empty! Cannot dequeue");
return -1;
}
int value = queueArray[front];
front = (front + 1) % maxSize;
currentSize--;
System.out.println("Dequeued: " + value);
return value;
}
public int peek() {
if (isEmpty()) {
System.out.println("Queue is empty!");
return -1;
}
return queueArray[front];
}
public boolean isEmpty() {
return currentSize == 0;
}
public boolean isFull() {
return currentSize == maxSize;
}
}
class Queue:
def __init__(self, size):
self.maxSize = size
self.queueArray = [0] * size
self.front = 0
self.rear = -1
self.currentSize = 0
# Enqueue: Add to rear
def enqueue(self, value):
if self.isFull():
print("Queue is full! Cannot enqueue", value)
return
self.rear = (self.rear + 1) % self.maxSize
self.queueArray[self.rear] = value
self.currentSize += 1
print("Enqueued:", value)
# Dequeue: Remove from front
def dequeue(self):
if self.isEmpty():
print("Queue is empty! Cannot dequeue")
return -1
value = self.queueArray[self.front]
self.front = (self.front + 1) % self.maxSize
self.currentSize -= 1
print("Dequeued:", value)
return value
def peek(self):
if self.isEmpty():
print("Queue is empty!")
return -1
return self.queueArray[self.front]
def isEmpty(self):
return self.currentSize == 0
def isFull(self):
return self.currentSize == self.maxSize
#include <stdio.h>
#define MAX 100
struct Queue {
int queueArray[MAX];
int front;
int rear;
int currentSize;
int maxSize;
};
// Initialize Queue
void initQueue(struct Queue* q, int size) {
q->maxSize = size;
q->front = 0;
q->rear = -1;
q->currentSize = 0;
}
// Enqueue
void enqueue(struct Queue* q, int value) {
if (q->currentSize == q->maxSize) {
printf("Queue is full! Cannot enqueue %d\n", value);
return;
}
q->rear = (q->rear + 1) % q->maxSize;
q->queueArray[q->rear] = value;
q->currentSize++;
printf("Enqueued: %d\n", value);
}
// Dequeue
int dequeue(struct Queue* q) {
if (q->currentSize == 0) {
printf("Queue is empty! Cannot dequeue\n");
return -1;
}
int value = q->queueArray[q->front];
q->front = (q->front + 1) % q->maxSize;
q->currentSize--;
printf("Dequeued: %d\n", value);
return value;
}
// Peek
int peek(struct Queue* q) {
if (q->currentSize == 0) {
printf("Queue is empty!\n");
return -1;
}
return q->queueArray[q->front];
}
#include <iostream>
using namespace std;
class Queue {
private:
int maxSize;
int* queueArray;
int front;
int rear;
int currentSize;
public:
Queue(int size) {
maxSize = size;
queueArray = new int[maxSize];
front = 0;
rear = -1;
currentSize = 0;
}
// Enqueue
void enqueue(int value) {
if (isFull()) {
cout << "Queue is full! Cannot enqueue " << value << endl;
return;
}
rear = (rear + 1) % maxSize;
queueArray[rear] = value;
currentSize++;
cout << "Enqueued: " << value << endl;
}
// Dequeue
int dequeue() {
if (isEmpty()) {
cout << "Queue is empty! Cannot dequeue" << endl;
return -1;
}
int value = queueArray[front];
front = (front + 1) % maxSize;
currentSize--;
cout << "Dequeued: " << value << endl;
return value;
}
int peek() {
if (isEmpty()) {
cout << "Queue is empty!" << endl;
return -1;
}
return queueArray[front];
}
bool isEmpty() {
return currentSize == 0;
}
bool isFull() {
return currentSize == maxSize;
}
};