Circular Queue Implementation Using Array in DSA Python - 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 performing the following operations?

Initialize queue with size 5.
Enqueue 10, 20, 30.
Dequeue one element.
Enqueue 40, 50.
Dequeue two elements.
Enqueue 60, 70.

Print the queue elements from front to rear.

DSA Python

class CircularQueue:
    def __init__(self, size):
        self.size = size
        self.queue = [None] * size
        self.front = -1
        self.rear = -1

    def enqueue(self, data):
        if (self.rear + 1) % self.size == self.front:
            return "Queue is Full"
        elif self.front == -1:
            self.front = 0
            self.rear = 0
            self.queue[self.rear] = data
        else:
            self.rear = (self.rear + 1) % self.size
            self.queue[self.rear] = data

    def dequeue(self):
        if self.front == -1:
            return "Queue is Empty"
        data = self.queue[self.front]
        if self.front == self.rear:
            self.front = -1
            self.rear = -1
        else:
            self.front = (self.front + 1) % self.size
        return data

    def display(self):
        if self.front == -1:
            return []
        elements = []
        i = self.front
        while True:
            elements.append(self.queue[i])
            if i == self.rear:
                break
            i = (i + 1) % self.size
        return elements

cq = CircularQueue(5)
cq.enqueue(10)
cq.enqueue(20)
cq.enqueue(30)
cq.dequeue()
cq.enqueue(40)
cq.enqueue(50)
cq.dequeue()
cq.dequeue()
cq.enqueue(60)
cq.enqueue(70)
print(cq.display())

A [20, 30, 40, 50]

B [30, 40, 50, 60, 70]

C [40, 50, 60, 70]

D [10, 20, 30, 40]

💡 Hint

Remember that the circular queue wraps around when rear reaches the end of the array.

After the operations, the queue contains 40, 50, 60, 70 in order from front to rear. Earlier elements were dequeued.

🧠 Conceptual

intermediate

Understanding Circular Queue Full Condition

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

A rear == size - 1

B front == 0 and rear == size - 1

C front == rear

D (rear + 1) % size == front

💡 Hint

Think about how the rear wraps around to the front in a circular queue.

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

🔧 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 Python

def dequeue(self):
    if self.front == -1:
        return "Queue is Empty"
    data = self.queue[self.front]
    if self.front == self.rear:
        self.front = -1
        self.rear = -1
    else:
        self.front = (self.front + 1) % self.size
    return data

cq = CircularQueue(3)
cq.dequeue()

A Returns 'Queue is Empty' string

B IndexError: list index out of range

C TypeError: unsupported operand type(s)

D AttributeError: 'CircularQueue' object has no attribute 'queue'

💡 Hint

Check what happens when front is -1 and dequeue is called.

The method returns the string 'Queue is Empty' when the queue is empty, no error occurs.

❓ Predict Output

advanced

Result of Circular Queue After Wrap-Around Enqueue

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

Enqueue 1, 2, 3.
Dequeue one element.
Enqueue 4.
Enqueue 5.

Print the queue elements from front to rear.

DSA Python

cq = CircularQueue(4)
cq.enqueue(1)
cq.enqueue(2)
cq.enqueue(3)
cq.dequeue()
cq.enqueue(4)
cq.enqueue(5)
print(cq.display())

A [2, 3, 4, 5]

B [1, 2, 3, 4]

C [3, 4, 5]

D [2, 3, 4]

💡 Hint

Remember the queue size is 4 and it wraps around when full.

After dequeuing 1, the queue has 2,3. Enqueue 4 and 5 fills the queue to [2,3,4,5].

🚀 Application

expert

Maximum Number of Elements in Circular Queue

If a circular queue is implemented using an array of size N, what is the maximum number of elements it can hold without resizing?

A N

B N - 1

C N + 1

D N // 2

💡 Hint

One slot is kept empty to distinguish full and empty states.

To differentiate full and empty states, one slot remains unused, so max elements = N - 1.