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).

Practice

1. What is the main feature of a deque (double-ended queue) compared to a regular queue?

easy

A. It only stores unique elements

B. Elements can only be added at the rear

C. Elements can be added or removed from both ends

D. Elements can only be removed from the front

Solution

1. Step 1: Understand queue vs deque

   A regular queue allows adding at rear and removing from front only.

2. Step 2: Identify deque feature

   A deque allows adding and removing elements from both front and rear ends.

3. Final Answer:

   Elements can be added or removed from both ends -> Option C

4. Quick Check:

   Deque = double-ended queue [OK]

Hint: Deque means double-ended, so both ends work [OK]

Common Mistakes:

• Thinking deque works like a normal queue
• Assuming elements can only be added at one end
• Confusing deque with stack

2. Which of the following is the correct syntax to add an element '5' to the front of a deque named d in Python?

easy

A. d.push_front(5)

B. d.addfront(5)

C. d.insert_front(5)

D. d.appendleft(5)

Solution

1. Step 1: Recall deque methods in Python

   Python's collections.deque uses appendleft() to add at front.

2. Step 2: Check method names

   Other options are not valid deque methods in Python.

3. Final Answer:

   d.appendleft(5) -> Option D

4. Quick Check:

   appendleft adds to front [OK]

Hint: Use appendleft() to add front in Python deque [OK]

Common Mistakes:

• Using non-existent methods like push_front
• Confusing append() with appendleft()
• Trying to use list methods on deque

3. What will be the output of the following code?

from collections import deque
d = deque([1, 2, 3])
d.appendleft(0)
d.pop()
print(list(d))

medium

A. [0, 1, 2]

B. [1, 2, 3, 0]

C. [0, 1, 2, 3]

D. [1, 2]

Solution

1. Step 1: Initial deque and appendleft

   Start with deque [1, 2, 3]. appendleft(0) adds 0 at front: [0, 1, 2, 3].

2. Step 2: pop removes from rear

   pop() removes last element 3: [0, 1, 2].

3. Final Answer:

   [0, 1, 2] -> Option A

4. Quick Check:

   appendleft + pop = [0,1,2] [OK]

Hint: appendleft adds front, pop removes rear [OK]

Common Mistakes:

• Thinking pop removes from front
• Ignoring appendleft effect
• Confusing list(d) output

4. Identify the error in the following code snippet:

from collections import deque
d = deque([10, 20, 30])
d.removeleft()
print(d)

medium

A. removeleft() is not a valid deque method

B. deque cannot be initialized with a list

C. print(d) should be print(list(d))

D. No error, code runs fine

Solution

1. Step 1: Check deque methods

   deque has no method named removeleft(); correct method to remove front is popleft().

2. Step 2: Validate other parts

   deque can be initialized with list; print(d) works; so no other errors.

3. Final Answer:

   removeleft() is not a valid deque method -> Option A

4. Quick Check:

   Use popleft() to remove front [OK]

Hint: Use popleft(), not removeleft() [OK]

Common Mistakes:

• Using non-existent removeleft() method
• Thinking print(d) causes error
• Confusing initialization syntax

5. You have a deque d = deque([1, 2, 3, 4]). You perform these operations:

d.pop()
d.appendleft(0)
d.popleft()
d.append(5)
print(list(d))

What is the final state of the deque?

hard

A. [0, 1, 2, 3, 5]

B. [1, 2, 3, 5]

C. [2, 3, 4, 5]

D. [0, 2, 3, 5]

Solution

1. Step 1: Trace each operation on deque

   Start: [1, 2, 3, 4]
   d.pop() removes 4: [1, 2, 3]
   d.appendleft(0): [0, 1, 2, 3]
   d.popleft() removes 0: [1, 2, 3]
   d.append(5): [1, 2, 3, 5]

2. Step 2: Confirm final deque state

   After all operations, deque is [1, 2, 3, 5].

3. Final Answer:

   [1, 2, 3, 5] -> Option B

4. Quick Check:

   pop + appendleft + popleft + append = [1,2,3,5] [OK]

Hint: Apply operations step-by-step on deque [OK]

Common Mistakes:

• Forgetting popleft removes front
• Mixing order of operations
• Assuming appendleft stays after popleft