Dequeue Operation in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after a sequence of dequeue operations

What is the state of the dequeue after performing the following operations?

Start with an empty dequeue.
Operations:
1. Add 10 to the rear
2. Add 20 to the rear
3. Add 5 to the front
4. Remove one element from the rear
5. Remove one element from the front

Print the dequeue from front to rear.

DSA Python

from collections import deque

dq = deque()
dq.append(10)  # rear
dq.append(20)  # rear
dq.appendleft(5)  # front
dq.pop()  # remove rear
dq.popleft()  # remove front
print(list(dq))

A [10, 20]

B [5, 10]

C [20]

D [10]

💡 Hint

Remember that append adds to rear and appendleft adds to front. pop removes from rear and popleft removes from front.

After adding 10 and 20 to rear, dequeue is [10, 20]. Adding 5 to front makes it [5, 10, 20]. Removing rear removes 20, so [5, 10]. Removing front removes 5, leaving [10].

❓ Predict Output

intermediate

Result of mixed enqueue and dequeue operations

Given an empty dequeue, perform these operations:
1. Add 1 to front
2. Add 2 to rear
3. Add 3 to front
4. Remove one element from rear
5. Add 4 to rear

What is the dequeue content from front to rear?

DSA Python

from collections import deque

dq = deque()
dq.appendleft(1)
dq.append(2)
dq.appendleft(3)
dq.pop()
dq.append(4)
print(list(dq))

A [3, 1, 4]

B [1, 3, 4]

C [3, 4]

D [1, 4]

💡 Hint

Track each operation carefully, noting where elements are added or removed.

Start: [] Add 1 front: [1] Add 2 rear: [1, 2] Add 3 front: [3, 1, 2] Remove rear: removes 2 → [3, 1] Add 4 rear: [3, 1, 4]

❓ Predict Output

advanced

Output of dequeue after multiple pops

Consider this code snippet:

from collections import deque

dq = deque([100, 200, 300, 400])
dq.popleft()
dq.pop()
dq.popleft()
print(list(dq))

What is the output?

DSA Python

from collections import deque

dq = deque([100, 200, 300, 400])
dq.popleft()
dq.pop()
dq.popleft()
print(list(dq))

A [200]

B [300]

C []

D [400]

💡 Hint

Remember popleft removes from front, pop removes from rear.

Initial: [100, 200, 300, 400] After popleft(): removes 100 → [200, 300, 400] After pop(): removes 400 → [200, 300] After popleft(): removes 200 → [300]

❓ Predict Output

advanced

Dequeue state after alternating adds and removes

What will be printed after this code runs?

from collections import deque

dq = deque()
dq.append(1)
dq.appendleft(2)
dq.append(3)
dq.popleft()
dq.pop()
dq.appendleft(4)
print(list(dq))

DSA Python

from collections import deque

dq = deque()
dq.append(1)
dq.appendleft(2)
dq.append(3)
dq.popleft()
dq.pop()
dq.appendleft(4)
print(list(dq))

A [2, 1]

B [1]

C [4, 1]

D [4]

💡 Hint

Follow each operation step-by-step, noting front and rear changes.

Start: [] append(1): [1] appendleft(2): [2, 1] append(3): [2, 1, 3] popleft(): removes 2 → [1, 3] pop(): removes 3 → [1] appendleft(4): [4, 1]

🧠 Conceptual

expert

Understanding time complexity of dequeue operations

Which statement correctly describes the time complexity of the main dequeue operations (append, appendleft, pop, popleft) in Python's collections.deque?

A All four operations run in O(1) time because deque is implemented as a doubly linked list.

B append and pop run in O(1), but appendleft and popleft run in O(n) because they shift elements.

C append and appendleft run in O(n), pop and popleft run in O(1) because of internal array resizing.

D All four operations run in O(n) time because deque uses a dynamic array.

💡 Hint

Think about how deque allows fast additions and removals at both ends.

Python's collections.deque is implemented as a doubly linked list or a block linked list, allowing append, appendleft, pop, and popleft to run in constant time O(1).