Dequeue Using Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Dequeue Operations

What is the printed state of the dequeue after these operations?

Operations:
1. Add 10 at rear
2. Add 20 at rear
3. Add 5 at front
4. Remove from rear
5. Add 15 at front

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

class Dequeue:
    def __init__(self):
        self.front = None
        self.rear = None

    def add_front(self, data):
        new_node = Node(data)
        if self.front is None:
            self.front = self.rear = new_node
        else:
            new_node.next = self.front
            self.front.prev = new_node
            self.front = new_node

    def add_rear(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = self.rear = new_node
        else:
            self.rear.next = new_node
            new_node.prev = self.rear
            self.rear = new_node

    def remove_front(self):
        if self.front is None:
            return None
        data = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        else:
            self.front.prev = None
        return data

    def remove_rear(self):
        if self.rear is None:
            return None
        data = self.rear.data
        self.rear = self.rear.prev
        if self.rear is None:
            self.front = None
        else:
            self.rear.next = None
        return data

    def display(self):
        current = self.front
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

dq = Dequeue()
dq.add_rear(10)
dq.add_rear(20)
dq.add_front(5)
dq.remove_rear()
dq.add_front(15)
dq.display()

A 5 -> 10 -> 15 -> null

B 15 -> 5 -> 10 -> null

C 15 -> 10 -> 5 -> null

D 10 -> 5 -> 15 -> null

💡 Hint

Trace each operation step-by-step, updating front and rear pointers.

After adding 10 and 20 at rear, dequeue is 10 -> 20. Adding 5 at front makes it 5 -> 10 -> 20. Removing rear removes 20, leaving 5 -> 10. Adding 15 at front results in 15 -> 5 -> 10.

🧠 Conceptual

intermediate

Number of Nodes After Operations

If you start with an empty dequeue and perform these operations:
add_front(1), add_rear(2), add_front(3), remove_rear(), remove_front(), add_rear(4)
How many nodes remain in the dequeue?

A 0

B 1

C 3

D 2

💡 Hint

Count nodes after each operation carefully.

Operations add 1 (front), 2 (rear), 3 (front) → 3 nodes. Removing rear removes 2 → 2 nodes. Removing front removes 3 → 1 node. Adding 4 at rear → 2 nodes total.

🔧 Debug

advanced

Identify the Bug in remove_front Method

What error will occur when calling remove_front on a dequeue with only one node, given this code snippet?

DSA Python

def remove_front(self):
    if self.front is None:
        return None
    data = self.front.data
    self.front = self.front.next
    self.front.prev = None
    return data

A No error, returns data correctly

B TypeError: unsupported operand type(s)

C AttributeError: 'NoneType' object has no attribute 'prev'

D IndexError: list index out of range

💡 Hint

Consider what happens when front becomes None after removal.

When the only node is removed, self.front becomes None. Then self.front.prev causes AttributeError because None has no attribute 'prev'.

❓ Predict Output

advanced

Output After Mixed Add and Remove Operations

What is the printed state of the dequeue after these operations?

Operations:
add_rear(7)
add_front(3)
add_rear(9)
remove_front()
remove_rear()
add_front(1)
add_rear(11)
display()

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

class Dequeue:
    def __init__(self):
        self.front = None
        self.rear = None

    def add_front(self, data):
        new_node = Node(data)
        if self.front is None:
            self.front = self.rear = new_node
        else:
            new_node.next = self.front
            self.front.prev = new_node
            self.front = new_node

    def add_rear(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = self.rear = new_node
        else:
            self.rear.next = new_node
            new_node.prev = self.rear
            self.rear = new_node

    def remove_front(self):
        if self.front is None:
            return None
        data = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        else:
            self.front.prev = None
        return data

    def remove_rear(self):
        if self.rear is None:
            return None
        data = self.rear.data
        self.rear = self.rear.prev
        if self.rear is None:
            self.front = None
        else:
            self.rear.next = None
        return data

    def display(self):
        current = self.front
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

dq = Dequeue()
dq.add_rear(7)
dq.add_front(3)
dq.add_rear(9)
dq.remove_front()
dq.remove_rear()
dq.add_front(1)
dq.add_rear(11)
dq.display()

A 1 -> 7 -> 11 -> null

B 3 -> 7 -> 9 -> null

C 7 -> 11 -> null

D 1 -> 9 -> 11 -> null

💡 Hint

Track the front and rear after each operation carefully.

Start: empty add_rear(7): 7 add_front(3): 3 -> 7 add_rear(9): 3 -> 7 -> 9 remove_front(): removes 3 → 7 -> 9 remove_rear(): removes 9 → 7 add_front(1): 1 -> 7 add_rear(11): 1 -> 7 -> 11

🧠 Conceptual

expert

Time Complexity of Dequeue Operations Using Linked List

What is the time complexity of add_front, add_rear, remove_front, and remove_rear operations in a dequeue implemented using a doubly linked list?

A All operations are O(1)

B add_front and add_rear are O(1), remove_front and remove_rear are O(n)

C add_front and remove_front are O(1), add_rear and remove_rear are O(n)

D All operations are O(n)

💡 Hint

Consider how pointers are updated in a doubly linked list.

In a doubly linked list, both ends are directly accessible. Adding or removing nodes at front or rear involves only pointer changes, so all operations take constant time O(1).