Circular Queue Implementation Using Array in DSA C++ - 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.
Dequeue two elements.
Enqueue 60, 70.

DSA C++

class CircularQueue {
    int *arr;
    int front, rear, size;
public:
    CircularQueue(int s) {
        size = s;
        arr = new int[size];
        front = -1;
        rear = -1;
    }
    bool isFull() {
        return ((rear + 1) % size == front);
    }
    bool isEmpty() {
        return (front == -1);
    }
    void enqueue(int val) {
        if (isFull()) return;
        if (isEmpty()) front = 0;
        rear = (rear + 1) % size;
        arr[rear] = val;
    }
    void dequeue() {
        if (isEmpty()) return;
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front = (front + 1) % size;
        }
    }
    void printQueue() {
        if (isEmpty()) {
            std::cout << "Queue is empty" << std::endl;
            return;
        }
        int i = front;
        while (true) {
            std::cout << arr[i] << " ";
            if (i == rear) break;
            i = (i + 1) % size;
        }
        std::cout << std::endl;
    }
};

int main() {
    CircularQueue q(5);
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.dequeue();
    q.enqueue(40);
    q.enqueue(50);
    q.dequeue();
    q.dequeue();
    q.enqueue(60);
    q.enqueue(70);
    q.printQueue();
    return 0;
}

A 10 20 30 40 50

B 40 50 60 70

C 20 30 40 50 60

D 30 40 50 60 70

💡 Hint

Track front and rear positions carefully after each enqueue and dequeue.

After the operations, the queue contains 40, 50, 60, 70 in order.

❓ Predict Output

intermediate

Output of Circular Queue Full Condition Check

What will be the output of the following code snippet?

int main() {
    CircularQueue q(3);
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    if (q.isFull()) std::cout << "Full" << std::endl;
    else std::cout << "Not Full" << std::endl;
    q.dequeue();
    q.enqueue(4);
    if (q.isFull()) std::cout << "Full" << std::endl;
    else std::cout << "Not Full" << std::endl;
    return 0;
}

DSA C++

class CircularQueue {
    int *arr;
    int front, rear, size;
public:
    CircularQueue(int s) {
        size = s;
        arr = new int[size];
        front = -1;
        rear = -1;
    }
    bool isFull() {
        return ((rear + 1) % size == front);
    }
    bool isEmpty() {
        return (front == -1);
    }
    void enqueue(int val) {
        if (isFull()) return;
        if (isEmpty()) front = 0;
        rear = (rear + 1) % size;
        arr[rear] = val;
    }
    void dequeue() {
        if (isEmpty()) return;
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front = (front + 1) % size;
        }
    }
};

A

Full
Not Full

B

Not Full
Not Full

C

Not Full
Full

D

Full
Full

💡 Hint

Remember that after dequeue, space frees up and queue may not be full.

Initially queue is full after 3 enqueues. After one dequeue and enqueue, queue is not full.

🔧 Debug

advanced

Identify the Bug in Circular Queue Dequeue Method

What error will occur when running this code snippet that uses the dequeue method?

void dequeue() {
    if (isEmpty()) return;
    if (front == rear) {
        front = -1;
        rear = -1;
    } else {
        front = (front - 1) % size;
    }
}

DSA C++

class CircularQueue {
    int *arr;
    int front, rear, size;
public:
    CircularQueue(int s) {
        size = s;
        arr = new int[size];
        front = -1;
        rear = -1;
    }
    bool isEmpty() {
        return (front == -1);
    }
    void dequeue() {
        if (isEmpty()) return;
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front = (front - 1) % size;
        }
    }
};

A Runtime error due to division by zero

B Compilation error due to missing return type

C No error, code works correctly

D The front index moves backward incorrectly causing wrong dequeue behavior

💡 Hint

Check how front index is updated in dequeue.

Dequeue should move front forward, not backward. Using (front - 1) % size causes incorrect behavior.

🧠 Conceptual

advanced

Why Use Circular Queue Instead of Linear Queue?

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

A It does not require front and rear pointers

B It is easier to implement than a linear queue

C It allows efficient use of space by reusing freed slots after dequeue operations

D It automatically sorts the elements in the queue

💡 Hint

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

Circular queue reuses empty spaces created by dequeues, avoiding wasted space unlike linear queue.

❓ Predict Output

expert

Final State of Circular Queue After Complex Operations

Given a circular queue of size 4, what is the printed output after these operations?

Enqueue 5, 10, 15.
Dequeue one element.
Enqueue 20.
Dequeue two elements.
Enqueue 25, 30.
Print queue.

DSA C++

class CircularQueue {
    int *arr;
    int front, rear, size;
public:
    CircularQueue(int s) {
        size = s;
        arr = new int[size];
        front = -1;
        rear = -1;
    }
    bool isFull() {
        return ((rear + 1) % size == front);
    }
    bool isEmpty() {
        return (front == -1);
    }
    void enqueue(int val) {
        if (isFull()) return;
        if (isEmpty()) front = 0;
        rear = (rear + 1) % size;
        arr[rear] = val;
    }
    void dequeue() {
        if (isEmpty()) return;
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front = (front + 1) % size;
        }
    }
    void printQueue() {
        if (isEmpty()) {
            std::cout << "Queue is empty" << std::endl;
            return;
        }
        int i = front;
        while (true) {
            std::cout << arr[i] << " ";
            if (i == rear) break;
            i = (i + 1) % size;
        }
        std::cout << std::endl;
    }
};

int main() {
    CircularQueue q(4);
    q.enqueue(5);
    q.enqueue(10);
    q.enqueue(15);
    q.dequeue();
    q.enqueue(20);
    q.dequeue();
    q.dequeue();
    q.enqueue(25);
    q.enqueue(30);
    q.printQueue();
    return 0;
}

A 25 30

B 15 20 25 30

C 20 25 30

D 10 15 20 25

💡 Hint

Track front and rear carefully after each operation, especially after multiple dequeues.

After all operations, queue contains 25 and 30 only.

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 eliminates the need for front and rear pointers

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

C. It automatically sorts the elements in the queue

D. It efficiently uses the array space by reusing freed slots

Solution

1. Step 1: Understand linear queue limitation

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

2. Step 2: Circular queue advantage

   Circular queue connects the end of the array back to the front, allowing reuse of empty slots freed by dequeuing.

3. Final Answer:

   It efficiently uses the array space by reusing freed slots -> Option D

4. Quick Check:

   Space reuse = Advantage [OK]

Hint: Circular queue reuses space freed by dequeued elements [OK]

Common Mistakes:

• Thinking circular queue sorts elements
• Believing circular queue removes need for pointers
• Assuming it supports multiple data types inherently

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 == n - 1

C. front == rear

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

Solution

1. Step 1: Understand full condition in circular queue

   In circular queue, queue is full when next position of rear is front, i.e., (rear + 1) modulo n equals front.

2. Step 2: Match condition with options

   front == (rear + 1) % n matches this condition: front == (rear + 1) % n.

3. Final Answer:

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

4. Quick Check:

   Full condition = front == (rear + 1) % n [OK]

Hint: Full when front is next to rear in circular manner [OK]

Common Mistakes:

• Using rear == n - 1 which is for linear queue
• Confusing front == rear as full (actually empty)
• Swapping front and rear in condition

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

medium

A. front = 2, rear = 1

B. front = 2, rear = 0

C. front = 3, rear = 0

D. front = 1, rear = 4

Solution

1. Step 1: Trace each operation and update pointers

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

2. Step 2: Final pointer values

   front = 2, rear = 0 which corresponds to front = 2, rear = 0.

3. Final Answer:

   front = 2, rear = 0 -> Option B

4. Quick Check:

   Trace pointers carefully [OK]

Hint: Track front and rear after each enqueue/dequeue [OK]

Common Mistakes:

• Not updating rear circularly after last index
• Confusing front and rear updates on dequeue
• Ignoring initial front = -1 condition

4. The following code snippet is part of a circular queue implementation. Identify the bug:

void enqueue(int value) {
  if ((rear + 1) % size == front) {
    cout << "Queue is full" << endl;
    return;
  }
  if (front == -1) front = 0;
  rear = (rear + 1) % size;
  arr[rear] = value;
}

medium

A. No bug, code is correct

B. The front pointer should be updated after rear

C. The initial check for empty queue should be before full check

D. The condition to check full queue is incorrect

Solution

1. Step 1: Analyze full queue condition

   The condition (rear + 1) % size == front correctly checks if queue is full in circular queue.

2. Step 2: Check front pointer update and enqueue steps

   If queue is empty (front == -1), front is set to 0 before inserting.
   rear is updated circularly and value inserted at arr[rear].

3. Final Answer:

   No bug, code is correct -> Option A

4. Quick Check:

   Full check and pointers update are correct [OK]

Hint: Full check uses modulo; front updated only if empty [OK]

Common Mistakes:

• Misplacing front update after rear
• Incorrect full condition without modulo
• Checking empty after full condition

5. You have a circular queue of size 6. After performing the following operations:
enqueue(5); enqueue(10); enqueue(15); dequeue(); dequeue(); enqueue(20); enqueue(25); enqueue(30); enqueue(35);
What will be the sequence of elements in the queue from front to rear?

hard

A. 20 -> 25 -> 30 -> 35

B. 10 -> 15 -> 20 -> 25 -> 30 -> 35

C. 15 -> 20 -> 25 -> 30 -> 35

D. 5 -> 10 -> 15 -> 20 -> 25 -> 30

Solution

1. Step 1: Trace each operation and queue content

   Start empty.
   enqueue(5): queue = [5]
   enqueue(10): queue = [5,10]
   enqueue(15): queue = [5,10,15]
   dequeue(): removes 5, queue = [10,15]
   dequeue(): removes 10, queue = [15]
   enqueue(20): queue = [15,20]
   enqueue(25): queue = [15,20,25]
   enqueue(30): queue = [15,20,25,30]
   enqueue(35): queue = [15,20,25,30,35]

2. Step 2: Check queue size and elements

   Queue size is 6, current elements are 5.
   From front to rear: 15 -> 20 -> 25 -> 30 -> 35

3. Final Answer:

   15 -> 20 -> 25 -> 30 -> 35 -> Option C

4. Quick Check:

   After dequeues, front moves; final elements start from 15 [OK]

Hint: Remove dequeued elements, then list remaining from front to rear [OK]

Common Mistakes:

• Forgetting to remove dequeued elements
• Listing elements before dequeue operations
• Assuming queue is full and ignoring last enqueue