Insert at Beginning of Doubly Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting nodes at the beginning

What is the printed state of the doubly linked list after inserting 10, then 20, then 30 at the beginning?

DSA Python

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        if self.head is not None:
            self.head.prev = new_node
        self.head = new_node

    def print_list(self):
        current = self.head
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(' -> '.join(result) + ' -> null')

dl = DoublyLinkedList()
dl.insert_at_beginning(10)
dl.insert_at_beginning(20)
dl.insert_at_beginning(30)
dl.print_list()

A 30 -> 20 -> 10 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> 10 -> null

D 30 -> 10 -> 20 -> null

💡 Hint

Remember that inserting at the beginning means the newest node becomes the head.

Each new node is added before the current head, so the list order is reversed from insertion order.

🧠 Conceptual

intermediate

Understanding pointer updates in insertion at beginning

When inserting a new node at the beginning of a doubly linked list, which pointers must be updated to maintain list integrity?

A New node's next and prev both point to old head; head remains unchanged

B New node's next points to old head; old head's prev points to new node; head updated to new node

C New node's prev points to old head; old head's next points to new node; head updated to new node

D Only head pointer is updated to new node; no other pointers change

💡 Hint

Think about how the new node connects forward and backward to the existing list.

The new node's next must point to the old head, and the old head's prev must point back to the new node. Then the head pointer is updated.

🔧 Debug

advanced

Identify the error in this insertion code

What error will this code cause when inserting at the beginning of a doubly linked list?

DSA Python

def insert_at_beginning(self, data):
    new_node = Node(data)
    new_node.prev = self.head
    self.head = new_node
    if new_node.next is not None:
        new_node.next.prev = new_node

A AttributeError because new_node.next is None and accessed without assignment

B No error, code works correctly

C Logical error: new_node.prev should be None, not self.head

D TypeError because new_node.prev is assigned a Node object instead of None

💡 Hint

Check what prev pointer of the new head node should be.

The new node inserted at beginning should have prev = None, but code sets prev = self.head (old head), which is incorrect.

❓ Predict Output

advanced

Output after multiple insertions and one traversal

What is the output of the following code?

DSA Python

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        if self.head:
            self.head.prev = new_node
        self.head = new_node

    def print_reverse(self):
        current = self.head
        while current and current.next:
            current = current.next
        result = []
        while current:
            result.append(str(current.data))
            current = current.prev
        print(' <- '.join(result) + ' <- null')

dl = DoublyLinkedList()
dl.insert_at_beginning(1)
dl.insert_at_beginning(2)
dl.insert_at_beginning(3)
dl.print_reverse()

A 1 <- 2 <- 3 <- null

B 3 <- 2 <- 1 <- null

C null

D 1 -> 2 -> 3 -> null

💡 Hint

The print_reverse method prints from tail to head.

After inserting 3,2,1 at beginning, list is 3->2->1. Reverse traversal prints 1 <- 2 <- 3 <- null.

🧠 Conceptual

expert

Why is updating the previous pointer important in doubly linked list insertion?

What problem arises if you insert a node at the beginning of a doubly linked list but forget to update the old head's prev pointer to the new node?

A No problem; the list will work fine without updating prev pointer

B Forward traversal will skip the new node, losing data

C The list will become singly linked automatically

D Backward traversal from the old head will be broken, causing incorrect or incomplete reverse iteration

💡 Hint

Think about how prev pointers help in moving backward through the list.

If old head's prev pointer is not updated, backward traversal starting from old head or tail will miss the new node, breaking the list's integrity.

Practice

1. What is the main purpose of inserting a node at the beginning of a doubly linked list?

easy

A. To add a new node as the first element of the list

B. To remove the last node from the list

C. To reverse the entire list

D. To find the middle node of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means adding a new node before the current first node.

2. Step 2: Identify the purpose

   This operation makes the new node the first element in the doubly linked list.

3. Final Answer:

   To add a new node as the first element of the list -> Option A

4. Quick Check:

   Insert at beginning = Add new first node [OK]

Hint: Insert at beginning means new node becomes the first [OK]

Common Mistakes:

• Confusing insertion at beginning with deletion
• Thinking it reverses the list
• Assuming it finds a node instead of adding

2. Which of the following is the correct syntax to create a new node and insert it at the beginning of a doubly linked list in Python?

easy

A. new_node = Node(data); new_node.prev = head; head.next = new_node; head = new_node

B. new_node = Node(data); head.next = new_node; new_node.prev = head; head = new_node

C. new_node = Node(data); new_node.next = head; head.prev = new_node; head = new_node

D. new_node = Node(data); head.prev = new_node; new_node.next = head.next; head = new_node

Solution

1. Step 1: Create new node and link next pointer

   new_node.next should point to current head to place it before head.

2. Step 2: Update previous head's prev pointer and head reference

   head.prev must point back to new_node, then update head to new_node.

3. Final Answer:

   new_node = Node(data); new_node.next = head; head.prev = new_node; head = new_node -> Option C

4. Quick Check:

   New node next = head, head prev = new node [OK]

Hint: New node next points to head; head prev points back [OK]

Common Mistakes:

• Swapping prev and next pointers
• Not updating head to new node
• Forgetting to update old head's prev pointer

3. What will be the output of the following code after inserting 10 at the beginning of the doubly linked list?

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

head = Node(20)
new_node = Node(10)
new_node.next = head
head.prev = new_node
head = new_node

# Print list forward
current = head
result = []
while current:
    result.append(current.data)
    current = current.next
print(result)

medium

A. [20, 10]

B. [10, 20]

C. [10]

D. [20]

Solution

1. Step 1: Insert 10 before 20

   New node with data 10 points next to old head (20), old head prev points back to new node.

2. Step 2: Traverse from new head and collect data

   Starting at head (10), next is 20, then None. So list is [10, 20].

3. Final Answer:

   [10, 20] -> Option B

4. Quick Check:

   List after insertion = [10, 20] [OK]

Hint: Traverse from head to next to see order [OK]

Common Mistakes:

• Confusing order and printing reversed list
• Not updating head pointer
• Printing only one node

4. Identify the error in the following code snippet that inserts a node at the beginning of a doubly linked list:

new_node = Node(5)
new_node.next = head
head = new_node
head.prev = new_node

medium

A. head.prev should be set before updating head

B. new_node.next should be None

C. head.prev should point to None, not new_node

D. No error, code is correct

Solution

1. Step 1: Analyze pointer assignments

   new_node.next points to old head (correct), but head = new_node happens before head.prev = new_node.

2. Step 2: Identify the error

   By the time head.prev = new_node executes, head is already the new_node, creating a self-loop. The old head's prev is never set. head.prev must be set before updating head to link the old head back correctly.

3. Final Answer:

   head.prev should be set before updating head -> Option A

4. Quick Check:

   Update old head.prev before head = new_node [OK]

Hint: Set head.prev before head = new_node [OK]

Common Mistakes:

• Setting prev pointer after head update incorrectly
• Making first node's prev point to itself
• Ignoring prev pointer for head node

5. Given a doubly linked list with nodes 30 <-> 40 <-> 50, write the sequence of node values after inserting 20 at the beginning and then 10 at the beginning. What is the final list?

hard

A. 10 <-> 30 <-> 20 <-> 40 <-> 50

B. 20 <-> 10 <-> 30 <-> 40 <-> 50

C. 30 <-> 40 <-> 50 <-> 20 <-> 10

D. 10 <-> 20 <-> 30 <-> 40 <-> 50

Solution

1. Step 1: Insert 20 at beginning

   New node 20 points next to 30, 30 prev points to 20. List becomes 20 <-> 30 <-> 40 <-> 50.

2. Step 2: Insert 10 at beginning

   New node 10 points next to 20, 20 prev points to 10. List becomes 10 <-> 20 <-> 30 <-> 40 <-> 50.

3. Final Answer:

   10 <-> 20 <-> 30 <-> 40 <-> 50 -> Option D

4. Quick Check:

   Insertions add nodes at front in order [OK]

Hint: Insertions at beginning stack nodes in reverse order [OK]

Common Mistakes:

• Inserting nodes in wrong order
• Appending instead of prepending
• Not updating prev pointers correctly