Queue Implementation Using Array in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after these queue operations?

Consider a queue implemented using an array with a fixed size of 5. Initially, the queue is empty.

Operations performed in order:

1. enqueue(10)
2. enqueue(20)
3. dequeue()
4. enqueue(30)
5. enqueue(40)
6. dequeue()
7. enqueue(50)

What is the state of the queue from front to rear?

DSA Python

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

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

    def dequeue(self):
        if self.front == -1 or self.front > self.rear:
            return "Queue Empty"
        else:
            val = self.queue[self.front]
            self.front += 1
            return val

    def display(self):
        if self.front == -1 or self.front > self.rear:
            return []
        return self.queue[self.front:self.rear+1]

q = Queue()
q.enqueue(10)
q.enqueue(20)
q.dequeue()
q.enqueue(30)
q.enqueue(40)
dq = q.dequeue()
q.enqueue(50)
print(q.display())

A [30, 40, 50]

B [20, 30, 40, 50]

C [40, 50]

D [10, 20, 30, 40, 50]

💡 Hint

Remember that dequeue removes from the front and enqueue adds at the rear. The queue does not shift elements after dequeue.

After enqueue(10) and enqueue(20), queue is [10, 20].

dequeue() removes 10, so queue front moves to 20.

enqueue(30) and enqueue(40) add at rear: [20, 30, 40].

dequeue() removes 20, front moves to 30.

enqueue(50) adds at rear: [30, 40, 50].

🧠 Conceptual

intermediate

What happens when you enqueue in a full queue implemented with an array?

In a fixed-size array queue implementation, what is the typical behavior when you try to enqueue an element but the queue is already full?

A The oldest element is removed to make space for the new element.

B The queue automatically resizes to accommodate the new element.

C The enqueue operation fails or returns an error indicating the queue is full.

D The new element overwrites the last element in the queue.

💡 Hint

Think about fixed size and no dynamic resizing.

In a fixed-size array queue, when full, enqueue cannot add new elements and typically returns an error or fails.

🔧 Debug

advanced

Identify the error in this dequeue method of array queue

What error will this dequeue method cause when called repeatedly on a queue?

DSA Python

def dequeue(self):
    if self.front == -1 or self.front > self.rear:
        return "Queue Empty"
    val = self.queue[self.front]
    self.front += 1
    if self.front > self.rear:
        self.front = self.rear = -1
    return val

A No error; works correctly resetting front and rear when empty.

B After all elements are dequeued, enqueue will fail because front and rear are not reset.

C It causes an IndexError when front exceeds rear because it accesses invalid index.

D It causes infinite loop because front is never incremented.

💡 Hint

Check how front and rear are reset after last element is dequeued.

The method resets front and rear to -1 when queue becomes empty, so no error occurs.

❓ Predict Output

advanced

What is the output of this circular queue enqueue sequence?

Given a circular queue of size 4, initially empty, perform these operations:

1. enqueue(1)
2. enqueue(2)
3. enqueue(3)
4. dequeue()
5. enqueue(4)
6. enqueue(5)

What is the queue content from front to rear?

DSA Python

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

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

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

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

cq = CircularQueue()
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 [3, 4, 5]

C [1, 2, 3, 4]

D [4, 5]

💡 Hint

Remember circular queue wraps around the array.

After enqueue 1,2,3 queue is [1,2,3].

dequeue removes 1, front moves.

enqueue 4 and 5 fill the queue wrapping around.

Queue content is [2,3,4,5] but size is 4, so last enqueue(5) fails.

Actually enqueue(5) succeeds because queue size is 4 and one slot is free after dequeue.

Final queue is [2,3,4,5] but since size is 4, only 3 elements can be stored after dequeue.

Correct final queue content is [3,4,5].

🧠 Conceptual

expert

Why is a circular queue preferred over a simple array queue?

Which of the following best explains why circular queue implementation is preferred over a simple array queue?

A Circular queue stores elements in sorted order automatically.

B Circular queue allows dynamic resizing of the array automatically.

C Circular queue removes the need for front and rear pointers.

D Circular queue efficiently uses all array slots by wrapping around, avoiding wasted space after dequeues.

💡 Hint

Think about what happens to space in a simple array queue after many dequeues.

Simple array queue wastes space at the front after dequeues because front moves forward but rear cannot wrap.

Circular queue wraps rear to front to reuse empty slots, making better use of space.