A circular queue is a fixed-size queue where the storage array is treated as a ring. When elements are dequeued from the front, those positions become available again for future insertions — eliminating the wasted space problem of linear array queues. The queue follows the FIFO (First In, First Out) principle: elements are added at the rear and removed from the front.
This post presents a circular queue implementation in Java using a static array-backed design, demonstrating enqueue, dequeue, peek, and display operations through a menu-driven console program.
Java Program: Circular Queue with Arrays
import java.io.*;
// Circular queue using a fixed-size array
class CQueue {
public int front; // Index pointing to the front element
public int rear; // Index pointing to the rear element
public int capacity; // Maximum number of elements
public int queue[]; // Backing array
public CQueue(int size) {
capacity = size;
queue = new int[capacity];
front = 0;
rear = -1; // -1 means no elements yet
}
// Returns true when rear has reached the last index
public boolean isFull() {
return rear == capacity - 1;
}
// Returns true when rear is behind front (no elements between them)
public boolean isEmpty() {
return rear < front;
}
// Adds an element to the rear of the queue
public void enqueue(int element) {
if (isFull()) {
System.out.println("No Space - Queue is full");
} else {
rear++;
queue[rear] = element;
}
}
// Removes and prints the element at the front of the queue
public void dequeue() {
if (isEmpty()) {
System.out.println("Queue is empty - nothing to remove");
} else {
System.out.println("Removed element: " + queue[front]);
front++;
}
}
// Displays all elements currently in the queue
public void display() {
if (isEmpty()) {
System.out.println("Queue is empty");
} else {
System.out.print("Queue: ");
for (int i = front; i <= rear; i++) {
System.out.print(queue[i] + " ");
}
System.out.println();
}
}
// Peeks at the front element without removing it
public void peek() {
if (isEmpty()) {
System.out.println("Queue is empty");
} else {
System.out.println("Front element: " + queue[front]);
}
}
}
public class CircularQueueDemo2 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter length of queue: ");
int length = Integer.parseInt(reader.readLine());
CQueue queue = new CQueue(length);
int option = 0;
char exitFlag = ' ';
do {
System.out.println();
System.out.println("--- Circular Queue Operations ---");
System.out.println("1. Insert an element");
System.out.println("2. Remove an element");
System.out.println("3. Display all elements");
System.out.println("4. Peek at front element");
System.out.println("5. Exit");
System.out.print("Select operation: ");
option = Integer.parseInt(reader.readLine());
switch (option) {
case 1:
System.out.print("Enter an element: ");
int element = Integer.parseInt(reader.readLine());
queue.enqueue(element);
break;
case 2:
queue.dequeue();
break;
case 3:
queue.display();
break;
case 4:
queue.peek();
break;
case 5:
exitFlag = 'Q';
System.out.println("Exiting...");
break;
default:
System.out.println("Invalid option");
}
} while (exitFlag != 'Q');
}
}
How the Code Works
- CQueue class — Holds a fixed-size array plus
front(starting at 0) andrear(starting at -1) pointers. - isFull() — Checks if
rearhas reachedcapacity - 1; no more slots available at the back. - isEmpty() — Returns true when
rear < front, meaning no elements sit between the two pointers. - enqueue() — Increments
rearand stores the element. Prints “No Space” if the queue is full. - dequeue() — Prints and removes the element at
front, then incrementsfront. - display() — Iterates from
fronttorear, printing all current queue elements.
Sample Output
Enter length of queue: 4
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 1
Enter an element: 10
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 1
Enter an element: 20
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 1
Enter an element: 30
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 1
Enter an element: 40
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 1
Enter an element: 50
No Space - Queue is full
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 3
Queue: 10 20 30 40
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 4
Front element: 10
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 2
Removed element: 10
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 2
Removed element: 20
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 3
Queue: 30 40
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 2
Removed element: 30
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 2
Removed element: 40
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 2
Queue is empty - nothing to remove
--- Circular Queue Operations ---
1. Insert an element
2. Remove an element
3. Display all elements
4. Peek at front element
5. Exit
Select operation: 5
Exiting...See Also
- Implementation of Circular Queue in Java with Array — Circular queue with full wraparound logic
- Java Implementation of Queue using Linked List — Unbounded queue using linked nodes
- Implementation of Stack in Java — The LIFO counterpart
Conclusion
Circular queues are a fundamental improvement over simple array queues because they reuse freed space. This implementation demonstrates the core FIFO mechanics using a straightforward array. For applications where slot reuse on wraparound is critical, see the fully circular implementation linked above, which advances both front and rear with modulo arithmetic.
No Comments yet!