Insert at Beginning of Doubly Linked List in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a doubly linked list?

A doubly linked list is a chain of nodes where each node has three parts: data, a link to the next node, and a link to the previous node. This allows moving forward and backward through the list.

beginner

What steps are needed to insert a new node at the beginning of a doubly linked list?

1. Create a new node with the given data.
2. Set the new node's next link to the current head.
3. Set the new node's previous link to None.
4. If the list is not empty, set the current head's previous link to the new node.
5. Update the head to be the new node.

intermediate

Why do we need to update the previous link of the old head node when inserting at the beginning?

Because the new node becomes the first node, the old head now comes after it. Its previous link must point back to the new node to keep the list connected both ways.

beginner

What happens if the doubly linked list is empty when inserting at the beginning?

The new node becomes the only node in the list. Its next and previous links are both None, and the head points to this new node.

beginner

Show the Python code snippet to insert a node at the beginning of a doubly linked list.

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

What link of the new node should be set to None when inserting at the beginning?

A Both previous and next links

B The next link

C The previous link

D No links should be None

The new node is the first node, so its previous link must be None. Its next link points to the old head.

When inserting at the beginning, what must be updated in the old head node?

A Its previous link to the new node

B Its next link to the new node

C Its data value

D Nothing needs to be updated

The old head's previous link must point to the new node to maintain the backward connection.

If the list is empty, what will be the next link of the new node after insertion at beginning?

A It points to None

B It points to the tail

C It points to the old head

D It points to itself

With no nodes, the new node's next link is None because there is no next node.

What is the time complexity of inserting a node at the beginning of a doubly linked list?

A O(n)

B O(n^2)

C O(log n)

D O(1)

Insertion at the beginning is done by changing a few pointers, so it takes constant time.

Which pointer in the doubly linked list node points to the next node?

A prev

B next

C head

D tail

The 'next' pointer points to the next node in the list.

Explain the process of inserting a new node at the beginning of a doubly linked list.

Think about how the links change to keep the list connected both ways.

Describe how the doubly linked list changes when inserting at the beginning if the list is empty versus not empty.

Consider the links of the new node and the old head in both cases.

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