Circular Queue Implementation Using Array in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Queue Enqueue and Dequeue Operations

What is the printed state of the circular queue after the following operations?

Initialize queue with size 5.
Enqueue 10, 20, 30.
Dequeue one element.
Enqueue 40, 50, 60.
Print queue contents from front to rear.

DSA Java

class CircularQueue {
    int[] arr;
    int front, rear, size, capacity;

    CircularQueue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        size = 0;
        rear = capacity - 1;
    }

    void enqueue(int item) {
        if (size == capacity) return;
        rear = (rear + 1) % capacity;
        arr[rear] = item;
        size++;
    }

    int dequeue() {
        if (size == 0) return -1;
        int item = arr[front];
        front = (front + 1) % capacity;
        size--;
        return item;
    }

    void printQueue() {
        int count = size;
        int i = front;
        while (count > 0) {
            System.out.print(arr[i] + " -> ");
            i = (i + 1) % capacity;
            count--;
        }
        System.out.print("null\n");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue q = new CircularQueue(5);
        q.enqueue(10);
        q.enqueue(20);
        q.enqueue(30);
        q.dequeue();
        q.enqueue(40);
        q.enqueue(50);
        q.enqueue(60);
        q.printQueue();
    }
}

A 10 -> 20 -> 30 -> 40 -> 50 -> null

B 20 -> 30 -> 40 -> 50 -> null

C 30 -> 40 -> 50 -> 60 -> null

D 20 -> 30 -> 40 -> 50 -> 60 -> null

💡 Hint

Remember that dequeue removes the front element and enqueue adds at the rear in a circular manner.

After enqueueing 10, 20, 30, the queue is [10, 20, 30]. Dequeue removes 10. Then enqueue 40, 50, 60 fills the queue to [20, 30, 40, 50, 60]. Printing from front to rear shows these elements in order.

🧠 Conceptual

intermediate

Understanding Circular Queue Full Condition

In a circular queue implemented using an array, which condition correctly checks if the queue is full?

A size == capacity

B (rear + 1) % capacity == front

C front == rear

D front == (rear + 1) % capacity

💡 Hint

Think about how the rear and front pointers move in a circular manner.

The queue is full when the next position of rear (circularly) is front. This means (rear + 1) % capacity == front.

🔧 Debug

advanced

Identify the Bug in Circular Queue Dequeue Method

What error will occur when running this dequeue method if the queue is empty?

DSA Java

int dequeue() {
    if (size == 0) return -1;
    int item = arr[front];
    front = (front + 1) % capacity;
    size--;
    return item;
}

A Returns -1 without error

B ArrayIndexOutOfBoundsException

C NullPointerException

D Infinite loop

💡 Hint

Check what happens when size is zero.

The method checks if size is zero and returns -1 immediately, so no exception occurs.

❓ Predict Output

advanced

Result of Circular Queue After Wrap-Around Enqueue

Given a circular queue of capacity 4, after these operations:
enqueue(1), enqueue(2), enqueue(3), dequeue(), dequeue(), enqueue(4), enqueue(5), enqueue(6)
What is the queue content printed from front to rear?

DSA Java

class CircularQueue {
    int[] arr;
    int front, rear, size, capacity;

    CircularQueue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        size = 0;
        rear = capacity - 1;
    }

    void enqueue(int item) {
        if (size == capacity) return;
        rear = (rear + 1) % capacity;
        arr[rear] = item;
        size++;
    }

    int dequeue() {
        if (size == 0) return -1;
        int item = arr[front];
        front = (front + 1) % capacity;
        size--;
        return item;
    }

    void printQueue() {
        int count = size;
        int i = front;
        while (count > 0) {
            System.out.print(arr[i] + " -> ");
            i = (i + 1) % capacity;
            count--;
        }
        System.out.print("null\n");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue q = new CircularQueue(4);
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.dequeue();
        q.dequeue();
        q.enqueue(4);
        q.enqueue(5);
        q.enqueue(6);
        q.printQueue();
    }
}

A 4 -> 5 -> 6 -> null

B 1 -> 2 -> 3 -> 4 -> null

C 3 -> 4 -> 5 -> 6 -> null

D 5 -> 6 -> null

💡 Hint

Remember the queue capacity and how front and rear wrap around.

After enqueuing 1,2,3 and dequeuing twice, one element (3) remains at front (index 2, size=1). Enqueuing 4 (rear=3), 5 (rear=0), 6 (rear=1) fills to size=4. Printing from front=2: 3 -> 4 -> 5 -> 6 -> null.

🧠 Conceptual

expert

Why Use Circular Queue Instead of Simple Queue?

Which is the main advantage of using a circular queue over a simple linear queue implemented with an array?

A It allows efficient reuse of empty spaces after dequeues without shifting elements

B It uses less memory than a simple queue

C It automatically sorts elements in ascending order

D It prevents duplicate elements from being enqueued

💡 Hint

Think about what happens when elements are dequeued in a simple array queue.

A circular queue reuses freed spaces by wrapping around, avoiding costly shifting of elements required in a simple linear queue.

Practice

1. What is the main advantage of using a circular queue over a simple linear queue when implemented using an array?

easy

A. It allows storing different data types in the same queue.

B. It efficiently utilizes the array space by reusing empty slots after dequeue operations.

C. It automatically sorts the elements in the queue.

D. It uses less memory than a linear queue.

Solution

1. Step 1: Understand linear queue limitation

   In a linear queue using an array, once the rear reaches the end, no more elements can be added even if there are empty slots at the front due to dequeues.

2. Step 2: Circular queue advantage

   A circular queue connects the end of the array back to the front, allowing reuse of empty slots and efficient space usage.

3. Final Answer:

   It efficiently utilizes the array space by reusing empty slots after dequeue operations. -> Option B

4. Quick Check:

   Space reuse = Advantage [OK]

Hint: Circular queue reuses space after dequeue, unlike linear queue [OK]

Common Mistakes:

• Thinking circular queue sorts elements
• Believing circular queue uses less memory
• Confusing data type flexibility with queue type

2. Which of the following is the correct condition to check if a circular queue is full when using an array of size n with front and rear pointers?

easy

A. front == (rear + 1) % n

B. rear == (front + 1) % n

C. front == rear

D. rear == n - 1

Solution

1. Step 1: Understand circular queue full condition

   In a circular queue, the queue is full when the next position of rear (rear + 1 modulo n) is equal to front.

2. Step 2: Apply modulo for wrap-around

   Using modulo ensures the rear wraps to the start of the array, so full condition is front == (rear + 1) % n.

3. Final Answer:

   front == (rear + 1) % n -> Option A

4. Quick Check:

   Full if next rear equals front [OK]

Hint: Full when front is just ahead of rear in circular manner [OK]

Common Mistakes:

• Using rear == (front + 1) % n (wrong direction)
• Checking front == rear (means empty, not full)
• Ignoring modulo wrap-around

3. Consider a circular queue of size 5 (indices 0 to 4). Initially, front = -1 and rear = -1. The following operations are performed:
enqueue(10), enqueue(20), enqueue(30), dequeue(), enqueue(40), enqueue(50), enqueue(60)
What will be the values of front and rear after these operations?

medium

A. front = 2, rear = 1

B. front = 0, rear = 4

C. front = 1, rear = 3

D. front = 1, rear = 0

Solution

1. Step 1: Trace each operation step-by-step

   Start: front = -1, rear = -1
   enqueue(10): front=0, rear=0
   enqueue(20): rear=1
   enqueue(30): rear=2
   dequeue(): front=1 (removes 10)
   enqueue(40): rear=3
   enqueue(50): rear=4
   enqueue(60): rear wraps to 0 (since (4+1)%5=0)

2. Step 2: Final front and rear values

   After last enqueue, front=1, rear=0

3. Final Answer:

   front = 1, rear = 0 -> Option D

4. Quick Check:

   Wrap rear with modulo, front moves on dequeue [OK]

Hint: Update rear with modulo; front moves on dequeue [OK]

Common Mistakes:

• Not wrapping rear index after reaching array end
• Not updating front after dequeue
• Confusing initial front and rear values

4. Given the following snippet of a circular queue enqueue method, identify the bug:

void enqueue(int value) {
  if ((rear + 1) % size == front) {
    System.out.println("Queue is full");
    return;
  }
  if (front == -1) front = 0;
  rear = (rear + 1) % size;
  queue[rear] = value;
}

medium

A. The front pointer should be updated after enqueue.

B. The condition to check full queue is incorrect.

C. The rear pointer is updated before inserting the value.

D. The method does not handle empty queue initialization.

Solution

1. Step 1: Identify standard enqueue order

   In standard circular queue implementations (wasting one slot to distinguish empty/full), the value is inserted at the current rear first: queue[rear] = value; then rear = (rear + 1) % size.

2. Step 2: Problem with given code

   This code updates rear first, then inserts. This causes false positives in the full check after dequeue operations make the queue empty, as front == (old rear + 1) % size, matching the full condition.

3. Final Answer:

   The rear pointer is updated before inserting the value. -> Option C

4. Quick Check:

   Standard order: insert then increment rear [OK]

Hint: Check pointer updates order carefully in enqueue method [OK]

Common Mistakes:

• Confusing front and rear updates
• Misunderstanding full condition logic
• Ignoring initial empty queue setup

5. You have a circular queue of size 6. After performing several enqueue and dequeue operations, the front is at index 4 and rear is at index 2. Which of the following statements is true about the queue's current state?

hard

A. The queue has elements from index 4 to 5 and 0 to 2.

B. The queue is full.

C. The queue is empty.

D. The queue has elements only between indices 2 and 4.

Solution

1. Step 1: Understand circular queue indexing

   With front at 4 and rear at 2 in a size 6 queue, the queue wraps around the end of the array.

2. Step 2: Identify occupied indices

   Elements are from front (4) to end (5), then from start (0) to rear (2), so indices 4,5,0,1,2 hold elements.

3. Final Answer:

   The queue has elements from index 4 to 5 and 0 to 2. -> Option A

4. Quick Check:

   Wrap-around means elements split across array ends [OK]

Hint: Front > rear means queue wraps around array end [OK]

Common Mistakes:

• Assuming front > rear means empty queue
• Thinking queue is full when front > rear
• Ignoring wrap-around in circular queue