Insert at Beginning Head Insert in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting nodes at the beginning?

Consider a singly linked list initially empty. We insert nodes with values 10, 20, and 30 at the beginning in that order. What is the final state of the list?

DSA Go

package main
import "fmt"
type Node struct {
    data int
    next *Node
}
func insertAtBeginning(head *Node, val int) *Node {
    newNode := &Node{data: val, next: head}
    return newNode
}
func printList(head *Node) {
    for head != nil {
        fmt.Print(head.data)
        if head.next != nil {
            fmt.Print(" -> ")
        }
        head = head.next
    }
    fmt.Println(" -> null")
}
func main() {
    var head *Node = nil
    head = insertAtBeginning(head, 10)
    head = insertAtBeginning(head, 20)
    head = insertAtBeginning(head, 30)
    printList(head)
}

A 30 -> 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> 10 -> null

D 30 -> 20 -> 10 -> null

💡 Hint

Remember, inserting at the beginning means the newest node becomes the new head.

Each insertion at the beginning places the new node before the current head. So inserting 10 first makes list: 10 -> null. Then inserting 20 at beginning makes: 20 -> 10 -> null. Finally inserting 30 at beginning makes: 30 -> 20 -> 10 -> null.

🧠 Conceptual

intermediate

What happens to the head pointer after inserting at the beginning?

When inserting a new node at the beginning of a singly linked list, which statement is true about the head pointer?

A The head pointer is updated to point to the new node.

B The head pointer remains unchanged.

C The head pointer points to the last node.

D The head pointer is set to nil.

💡 Hint

Think about which node is the first after insertion.

Inserting at the beginning means the new node becomes the first node. So the head pointer must be updated to point to this new node.

🔧 Debug

advanced

Find the bug in this head insert function

This Go function is supposed to insert a new node at the beginning of a singly linked list. What is the bug?

DSA Go

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

A The function returns the old head instead of the new node.

B The function does not create a new node.

C The new node's next pointer is not set to the current head.

D The new node's data field is not initialized.

💡 Hint

Check what the new node's next pointer should be after insertion.

The new node's next pointer must point to the current head to maintain the list. Setting it to nil breaks the chain.

📝 Syntax

advanced

Which option correctly inserts a node at the beginning?

Choose the correct Go code snippet that inserts a new node with value val at the beginning of a singly linked list with head pointer head.

A

newNode := &Node{data: val}
newNode.next = head
head = newNode

B

newNode := &Node{data: val, next: head}
head = newNode

C

newNode := &Node{data: val}
head.next = newNode
head = newNode

D

newNode := &Node{data: val}
newNode.next = nil
head = newNode

💡 Hint

Remember to link the new node to the old head and update head.

Option A correctly creates a new node, sets its next to head, and updates head to newNode. Option A tries to assign head but does not update the original head pointer outside the function. Option A incorrectly sets head.next which is wrong for head insert. Option A sets next to nil, breaking the list.

🚀 Application

expert

After multiple head inserts, what is the sum of all node values?

Starting with an empty singly linked list, you insert the values 5, 15, 25, 35 at the beginning in that order. What is the sum of all node values in the final list?

A 100

B 80

C 75

D 60

💡 Hint

Sum all inserted values regardless of order.

Sum of 5 + 15 + 25 + 35 = 80. The order of insertion does not affect the sum.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Adds a new node at the end of the list

B. Searches for a node at the beginning

C. Deletes the first node of the list

D. Adds a new node at the start of the list, making it the new head

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Insert at beginning changes head

   Inserting at beginning means creating a new node and making it the new head, linking it to the old head.

3. Final Answer:

   Adds a new node at the start of the list, making it the new head -> Option D

4. Quick Check:

   Insert at beginning = new head node [OK]

Hint: New node becomes head, old head moves next [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it searches nodes

2. Which of the following Go code snippets correctly inserts a new node with value 10 at the beginning of a singly linked list?

easy

A. newNode := &Node{data: 10, next: head}
head = newNode

B. head.next = &Node{data: 10}
head = head.next

C. newNode := &Node{data: 10}
head.next = newNode

D. head = &Node{data: 10}
head.next = nil

Solution

1. Step 1: Create new node pointing to current head

   newNode is created with data 10 and next pointing to current head.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the first node.

3. Final Answer:

   newNode := &Node{data: 10, next: head}\nhead = newNode -> Option A

4. Quick Check:

   New node points to old head, head updated [OK]

Hint: New node's next = old head; head = new node [OK]

Common Mistakes:

• Not linking new node to old head
• Changing head.next instead of head
• Forgetting to update head pointer

3. What will be the output linked list after executing this Go code snippet?

package main
import "fmt"

type Node struct {
  data int
  next *Node
}

func main() {
  head := &Node{data: 5, next: nil}
  newNode := &Node{data: 3, next: head}
  head = newNode
  newNode2 := &Node{data: 1, next: head}
  head = newNode2

  // Print list
  current := head
  for current != nil {
    fmt.Print(current.data, " -> ")
    current = current.next
  }
  fmt.Print("null")
}

medium

A. 1 -> 3 -> 5 -> null

B. 5 -> 3 -> 1 -> null

C. 3 -> 1 -> 5 -> null

D. null

Solution

1. Step 1: Insert 3 at beginning

   New node with 3 points to 5, head updated to 3.

2. Step 2: Insert 1 at beginning

   New node with 1 points to 3, head updated to 1.

3. Step 3: Print list from head

   Traverse from head: 1 -> 3 -> 5 -> null.

4. Final Answer:

   1 -> 3 -> 5 -> null -> Option A

5. Quick Check:

   Head insert order reversed list [OK]

Hint: New nodes become head, so list order reverses insert order [OK]

Common Mistakes:

• Printing in insertion order instead of head order
• Confusing next pointers
• Not updating head after insert

4. Identify the error in this Go code that tries to insert a new node with value 7 at the beginning of a linked list:

type Node struct {
  data int
  next *Node
}

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

medium

A. The function should not return head

B. head should not be reassigned inside the function

C. newNode.next should point to head, not head.next

D. newNode is not initialized correctly

Solution

1. Step 1: Check newNode.next assignment

   It incorrectly points to head.next instead of head, skipping the current head node.

2. Step 2: Correct pointer to head

   newNode.next must point to head to insert before it.

3. Final Answer:

   newNode.next should point to head, not head.next -> Option C

4. Quick Check:

   Link new node to head, not head.next [OK]

Hint: New node's next = head, not head.next [OK]

Common Mistakes:

• Linking new node to head.next skipping head
• Not updating head pointer correctly
• Ignoring return value of updated head

5. Given a singly linked list with nodes containing integer values, write a Go function to insert multiple values at the beginning in order, so the final list reflects the insertion order. Which approach correctly achieves this?

hard

A. Insert each new value at the end one by one.

B. Insert each new value at the beginning but reverse the input slice before inserting.

C. Insert each new value at the beginning one by one.

D. Insert each new value at the end but reverse the input slice before inserting.

Solution

1. Step 1: Understand insertion order at beginning

   Inserting at beginning reverses order because new nodes become head.

2. Step 2: Reverse input slice before inserting

   Reversing input before inserting at beginning restores original order in final list.

3. Final Answer:

   Insert each new value at the beginning but reverse the input slice before inserting. -> Option B

4. Quick Check:

   Reverse input + head insert = original order [OK]

Hint: Reverse input before head inserts to keep order [OK]

Common Mistakes:

• Inserting at beginning without reversing input
• Inserting at end without reversing input
• Confusing insert at beginning with insert at end