Insert at Beginning of Doubly Linked List in DSA Go - 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 two links: one to the next node and one to the previous node. This allows moving forward and backward through the list.

beginner

What happens when you insert a node at the beginning of a doubly linked list?

The new node becomes the head. Its next link points to the old head, and the old head's previous link points back to the new node. The new node's previous link is null.

beginner

In Go, what fields does a node in a doubly linked list typically have?

A node usually has three fields: the data it holds, a pointer to the next node, and a pointer to the previous node.

intermediate

Why do we update the previous pointer of the old head when inserting at the beginning?

Because the old head now comes after the new node, so its previous pointer must point back to the new node to keep the list connected both ways.

beginner

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

It is O(1) because we only change a few pointers without traversing the list.

When inserting at the beginning of a doubly linked list, what should the new node's previous pointer be?

A Null (or nil)

B Point to the old head

C Point to the last node

D Point to itself

The new node is the first node, so its previous pointer should be null (or nil in Go).

Which pointer of the old head node must be updated when inserting a new node at the beginning?

A Next pointer

B Previous pointer

C Data pointer

D No pointer needs updating

The old head's previous pointer must point to the new node after insertion.

What is the first step when inserting a new node at the beginning of a doubly linked list?

A Set head to null

B Set new node's previous to current head

C Set new node's next to current head

D Traverse to the last node

We first link the new node's next pointer to the current head.

If the list is empty, what should the new node's next and previous pointers be after insertion?

A Both point to itself

B Both point to the old head

C Next points to null, previous points to head

D Next points to null, previous points to null

When the list is empty, the new node is alone, so both pointers are null.

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

A O(1)

B O(log n)

C O(n)

D O(n^2)

Insertion at the beginning is done in constant time O(1) because it involves only pointer changes.

Explain step-by-step how to insert a new node at the beginning of a doubly linked list.

Think about how pointers connect nodes forward and backward.

Describe how the pointers change when inserting a node at the beginning of a doubly linked list that already has nodes.

Focus on the links between new node and old head.

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 before the current head node

B. To add a new node after the tail node

C. To delete the first node of the list

D. To reverse the entire list

Solution

1. Step 1: Understand the head node position

   The head node is the first node in the doubly linked list.

2. Step 2: Insert new node before head

   Inserting at the beginning means placing the new node before the current head and updating pointers.

3. Final Answer:

   To add a new node before the current head node -> Option A

4. Quick Check:

   Insert at beginning = add before head [OK]

Hint: Beginning means before the head node [OK]

Common Mistakes:

• Confusing beginning with end insertion
• Thinking insertion deletes nodes
• Assuming insertion reverses list

2. Which of the following Go code snippets correctly updates the previous pointer of the old head node when inserting a new node at the beginning?

easy

A. newNode.prev = oldHead

B. oldHead.prev = newNode

C. newNode.next = oldHead.prev

D. oldHead.next = newNode

Solution

1. Step 1: Identify pointer to update

   When inserting at beginning, old head's previous pointer must point to new node.

2. Step 2: Correct assignment

   Setting oldHead.prev = newNode correctly links old head back to new node.

3. Final Answer:

   oldHead.prev = newNode -> Option B

4. Quick Check:

   Old head prev points to new node [OK]

Hint: Old head's prev points to new node [OK]

Common Mistakes:

• Assigning newNode.prev incorrectly
• Mixing next and prev pointers
• Updating oldHead.next instead of prev

3. Consider this Go code inserting nodes at the beginning of a doubly linked list:

type Node struct {
  data int
  prev *Node
  next *Node
}

func insertAtBeginning(head **Node, data int) {
  newNode := &Node{data: data}
  newNode.next = *head
  if *head != nil {
    (*head).prev = newNode
  }
  *head = newNode
}

func main() {
  var head *Node
  insertAtBeginning(&head, 10)
  insertAtBeginning(&head, 20)
  insertAtBeginning(&head, 30)
  // Print list from head
  curr := head
  for curr != nil {
    fmt.Print(curr.data, " -> ")
    curr = curr.next
  }
  fmt.Print("null")
}

What is the printed output?

medium

A. 20 -> 30 -> 10 -> null

B. 10 -> 20 -> 30 -> null

C. null

D. 30 -> 20 -> 10 -> null

Solution

1. Step 1: Trace insertions order

   Nodes inserted in order: 10, then 20 at beginning, then 30 at beginning.

2. Step 2: List after insertions

   After all insertions, list is 30 (head) -> 20 -> 10 -> null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option D

4. Quick Check:

   Last inserted node is new head [OK]

Hint: Last inserted node becomes new head [OK]

Common Mistakes:

• Assuming insertion adds at end
• Confusing order of nodes
• Ignoring pointer updates

4. The following Go function attempts to insert a node at the beginning of a doubly linked list but causes a runtime panic:

func insertAtBeginning(head *Node, data int) {
  newNode := &Node{data: data}
  newNode.next = head
  head.prev = newNode
  head = newNode
}

What is the main error causing the panic?

medium

A. head is nil and head.prev causes nil pointer dereference

B. newNode.next is not assigned correctly

C. head = newNode does not update original head pointer

D. data field is not initialized

Solution

1. Step 1: Check nil pointer usage

   If head is nil, accessing head.prev causes runtime panic (nil pointer dereference).

2. Step 2: Identify cause of panic

   Function does not check if head is nil before head.prev = newNode, causing panic.

3. Final Answer:

   head is nil and head.prev causes nil pointer dereference -> Option A

4. Quick Check:

   Accessing prev on nil head causes panic [OK]

Hint: Check for nil before accessing head.prev [OK]

Common Mistakes:

• Ignoring nil check before pointer access
• Thinking assignment head = newNode updates caller
• Assuming data field causes panic

5. You have a doubly linked list with nodes: 5 <-> 10 <-> 15. You want to insert a new node with value 3 at the beginning. After insertion, what will be the correct sequence of nodes when traversed from head to tail?

hard

A. 15 -> 10 -> 5 -> 3 -> null

B. 5 -> 10 -> 15 -> 3 -> null

C. 3 -> 5 -> 10 -> 15 -> null

D. 3 -> 15 -> 10 -> 5 -> null

Solution

1. Step 1: Understand insertion at beginning

   New node with value 3 is added before current head (5).

2. Step 2: Update pointers and traverse

   After insertion, list is 3 (head) -> 5 -> 10 -> 15 -> null.

3. Final Answer:

   3 -> 5 -> 10 -> 15 -> null -> Option C

4. Quick Check:

   New node becomes new head [OK]

Hint: New node becomes new head, old head shifts right [OK]

Common Mistakes:

• Inserting at end instead of beginning
• Reversing node order incorrectly
• Not updating head pointer