moves the front pointer correctly after a dequeue.
Circular Queue States
Empty Queue
Front = -1 Rear = -1
Queue[]
Queue with One Element
Front ↓
10 ↑ Rear
Wrapped Queue
Index
0 1 2 3 4 60 _ 30 40 50
Front = 2 Rear = 0
Logical Queue
30 → 40 → 50 → 60
Queue Operations
| Operation | Description | | --------- | ----------------------- | | Enqueue | Insert at Rear | | Dequeue | Remove from Front | | Peek | View Front element | | isEmpty | Check if Queue is empty | | isFull | Check if Queue is full | | Size | Number of elements | | Display | Print Queue |
Enqueue Operation
Current Queue
Front ↓ 30 → 40 → 50 ↑ Rear
Insert
enqueue(60)
Algorithm
If Queue is Full
Overflow Else If Queue is Empty Front = Rear = 0 Else Rear = (Rear + 1) % Capacity Insert value
if (isEmpty()) { System.out.println("Queue is Empty"); return; } int i = front; while (true) { System.out.print(queue[i] + " "); if (i == rear) break; i = (i + 1) % capacity; } System.out.println(); }
Complete Java Implementation
public class CircularQueue {
private int[] queue; private int front; private int rear; private int size; private int capacity; public CircularQueue(int capacity) { this.capacity = capacity; queue = new int[capacity]; front = -1; rear = -1; size = 0; } public boolean isEmpty() { return front == -1; } public boolean isFull() { return (rear + 1) % capacity == front; } public void enqueue(int value) { if (isFull()) { System.out.println("Queue Overflow"); return; } if (isEmpty()) { front = rear = 0; } else { rear = (rear + 1) % capacity; } queue[rear] = value; size++; } public int dequeue() { if (isEmpty()) { System.out.println("Queue Underflow"); return -1; } int value = queue[front]; if (front == rear) { front = rear = -1; } else { front = (front + 1) % capacity; } size--; return value; } public int peek() { if (isEmpty()) { System.out.println("Queue is Empty"); return -1; } return queue[front]; } public int size() { return size; } public void display() { if (isEmpty()) { System.out.println("Queue is Empty"); return; } int i = front; while (true) { System.out.print(queue[i] + " "); if (i == rear) break; i = (i + 1) % capacity; } System.out.println(); } public static void main(String[] args) { CircularQueue queue = new CircularQueue(5); queue.enqueue(10); queue.enqueue(20); queue.enqueue(30); queue.enqueue(40); queue.enqueue(50); queue.display(); System.out.println("Removed: " + queue.dequeue()); System.out.println("Removed: " + queue.dequeue()); queue.enqueue(60); queue.enqueue(70); queue.display(); System.out.println("Front: " + queue.peek()); System.out.println("Size: " + queue.size()); } }
| Feature | Linear Queue | Circular Queue | | ----------------------------------- | ------------ | -------------- | | Memory Reuse | ❌ No | ✅ Yes | | Overflow Before Array Is Truly Full | Yes | No | | Wrap-around | No | Yes | | Efficient Space Utilization | No | Yes | | Enqueue | O(1) | O(1) | | Dequeue | O(1) | O(1) |
Advantages
Eliminates memory wastage found in linear queues.
Efficiently reuses freed array positions.
All primary operations run in O(1) time.
Ideal for fixed-size buffers and scheduling systems.
Simple wrap-around logic using the modulo operator.
Disadvantages
Fixed capacity unless resized manually.
Wrap-around logic is more complex than a linear queue.
Incorrect pointer updates can lead to subtle bugs.
Real-World Applications
CPU scheduling (Round Robin)
Circular buffers
Keyboard input buffers
Audio and video streaming
Network packet buffering
Embedded systems
Producer–Consumer problems
Common Interview Questions
Why is a Circular Queue better than a Linear Queue?
What role does the modulo (%) operator play?
How do you detect if a Circular Queue is full?
How do you distinguish between an empty queue and a full queue?
What happens when rear reaches the last index?
Why are enqueue() and dequeue() both O(1)?
Where are Circular Queues used in real-world systems?
Common Mistakes
Forgetting to use the modulo operator while updating front or rear.
Incorrectly checking the full condition.
Not resetting front and rear when removing the last element.
Confusing the physical array layout with the logical queue order.
Best Practices
Maintain a separate size variable when possible—it simplifies state management.
Use the modulo operator consistently for pointer updates.
Reset the queue to the empty state (front = rear = -1) after removing the last element.
For production Java code, prefer ArrayDeque unless a fixed-capacity circular buffer is specifically required.
Chapter Summary
A Circular Queue is an optimized array-based queue that treats the array as a circle.
It solves the memory wastage problem of a linear queue by reusing freed positions through wrap-around.
The modulo (%) operator enables efficient circular indexing for both front and rear.
Core operations (enqueue, dequeue, peek) execute in O(1) time.
Circular Queues are widely used in operating systems, networking, embedded systems, and buffering applications where efficient use of fixed-size memory is essential.
Next Chapter
Chapter 10 — Queue Using Linked List (Java)
In the next chapter, you’ll learn:
Dynamic Queue implementation using a Linked List.
Node structure and memory layout.
Why linked-list queues don’t suffer from fixed-capacity limitations.
