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, 60.
Print queue contents from front to rear.

DSA C

int size = 5;
int queue[5];
int front = -1, rear = -1;

// Enqueue function
void enqueue(int val) {
    if ((rear + 1) % size == front) return; // full
    if (front == -1) front = 0;
    rear = (rear + 1) % size;
    queue[rear] = val;
}

// Dequeue function
int dequeue() {
    if (front == -1) return -1; // empty
    int val = queue[front];
    if (front == rear) {
        front = rear = -1;
    } else {
        front = (front + 1) % size;
    }
    return val;
}

// Operations
enqueue(10);
enqueue(20);
enqueue(30);
dequeue();
enqueue(40);
enqueue(50);
enqueue(60);

// Print queue
int i = front;
while (true) {
    printf("%d ", queue[i]);
    if (i == rear) break;
    i = (i + 1) % size;
}

A 30 40 50 60

B 20 30 40 50 60

C 10 20 30 40 50

D 20 30 40 50

💡 Hint

Remember that dequeue removes the front element and enqueue adds at rear using modulo for wrap-around.

After enqueueing 10,20,30 queue is [10,20,30]. Dequeue removes 10. Then enqueue 40,50,60 fills the queue circularly. Final queue is 20 30 40 50 60.

🧠 Conceptual

intermediate

Capacity Check in Circular Queue

In a circular queue implemented with an array of size N, which condition correctly checks if the queue is full?

A (rear + 1) % N == front

B rear == N - 1

C front == rear

D front == -1

💡 Hint

Think about how rear and front wrap around in a circular queue.

The queue is full when the next position of rear (circularly) equals front, meaning no space left.

🔧 Debug

advanced

Identify the Bug in Circular Queue Dequeue

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

DSA C

int dequeue() {
    if (front == -1) {
        printf("Queue is empty\n");
        return -1;
    }
    int val = queue[front];
    if (front == rear) {
        front = rear = -1;
    } else {
        front = (front + 1) % size;
    }
    return val;
}

A Runs correctly and returns front element

B Prints 'Queue is empty' and returns -1

C Compilation error due to missing return statement

D Returns garbage value because no return after empty check

💡 Hint

Check what happens after printing 'Queue is empty' when queue is empty.

If queue is empty, function prints message but continues to access queue[front] which is invalid, returning garbage.

📝 Syntax

advanced

Correct Circular Queue Enqueue Syntax

Which option correctly updates rear and inserts value val in a circular queue of size N?

A

rear = (rear + 1) % N;
queue[rear] = val;

B

rear = rear + 1 % N;
queue[rear] = val;

C

rear = (rear + 1) / N;
queue[rear] = val;

D

rear = rear + 1 % N;
queue[val] = rear;

💡 Hint

Remember operator precedence and modulo usage for circular increment.

Option A correctly increments rear circularly and assigns val at that position.

🚀 Application

expert

Final Queue State After Mixed Operations

Given a circular queue of size 4, starting empty, perform these operations:
enqueue(1), enqueue(2), enqueue(3), dequeue(), enqueue(4), dequeue(), enqueue(5), enqueue(6).
What is the queue content from front to rear?

A 4 5 6

B 2 3 4 5

C 3 4 5 6

D 1 2 3 4

💡 Hint

Track front and rear carefully after each operation with wrap-around.

After operations, queue holds 3,4,5,6 in order from front to rear.