Push Using Linked List Node in DSA Go - Execution Trace

Concept Flow - Push Using Linked List Node

Create new node with value

↓

Set new node's next to current head

↓

Update head to new node

↓

Done

This flow shows how a new node is created and added at the start of the linked list by adjusting pointers.

Execution Sample

DSA Go

func push(head *Node, val int) *Node {
    newNode := &Node{val, head}
    return newNode
}

This function creates a new node with the given value and pushes it to the front of the linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Start with empty list	None	head = nil	null
2	Create new node with value 10	10 -> null	newNode.next = nil	10 -> null
3	Set newNode.next to head (nil)	10 -> null	newNode.next = head (nil)	10 -> null
4	Update head to newNode	10 -> null	head = newNode	10 -> null
5	Create new node with value 20	20 -> 10 -> null	newNode.next = head (10)	20 -> 10 -> null
6	Update head to newNode	20 -> 10 -> null	head = newNode	20 -> 10 -> null
7	Create new node with value 30	30 -> 20 -> 10 -> null	newNode.next = head (20)	30 -> 20 -> 10 -> null
8	Update head to newNode	30 -> 20 -> 10 -> null	head = newNode	30 -> 20 -> 10 -> null
9	End of push operations	30 -> 20 -> 10 -> null	head points to 30	30 -> 20 -> 10 -> null

💡 No more push operations; list head points to last pushed node.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 7	Final
head	nil	10	20	30	30
newNode	nil	10	20	30	nil
newNode.next	nil	nil	10	20	nil

Key Moments - 3 Insights

Why does the new node's next pointer point to the current head?

Because in step 3 and 5, newNode.next is set to head to link the new node to the existing list, preserving the chain.

What happens if the list is empty before pushing?

As shown in step 1 and 2, head is nil, so newNode.next is nil, making the new node the only node in the list.

Why do we update head to newNode after setting newNode.next?

Because after linking the new node to the list, head must point to the new first node to maintain the list start, as in steps 4, 6, and 8.

Visual Quiz - 3 Questions

Look at the execution table, what is the list state after step 5?

A 30 -> 20 -> 10 -> null

B 10 -> 20 -> null

C 20 -> 10 -> null

D 10 -> null

💡 Hint

Check the 'Visual State' column at step 5 in the execution table.

At which step does the head pointer first change from nil to a node?

A Step 1

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Pointer Changes' column to see when head is updated from nil.

If we push a new node with value 40 after step 8, what will be the new head value?

A 40

B 10

C 30

D 20

💡 Hint

Refer to the pattern of head updates in the variable_tracker and execution_table after each push.

Concept Snapshot

Push Using Linked List Node:
- Create new node with value
- Set new node's next to current head
- Update head to new node
- New node becomes list start
- List grows at front with each push

Full Transcript

This concept shows how to add a new node at the start of a linked list. We create a new node with the given value, link it to the current head, then update the head to this new node. This way, the list grows by adding nodes at the front. The execution table traces each step, showing how pointers and list state change. The variable tracker follows head and newNode pointers. Key moments clarify why we link newNode.next to head before updating head. The visual quiz tests understanding of list state and pointer updates.

Practice

1. What does the push operation do in a linked list when using a node?

easy

A. Deletes the entire linked list

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Adds a new node at the beginning of the list

Solution

1. Step 1: Understand push operation in linked list

   The push operation adds a new node at the start (head) of the linked list.

2. Step 2: Effect of push on list structure

   The new node becomes the head, and its next pointer points to the previous head node.

3. Final Answer:

   Adds a new node at the beginning of the list -> Option D

4. Quick Check:

   Push = Add at head [OK]

Hint: Push always adds node at the start of the list [OK]

Common Mistakes:

• Thinking push adds at the end
• Confusing push with pop
• Assuming push deletes nodes

2. Which of the following is the correct syntax to create a new node and push it onto a linked list in Go?

easy

A. newNode := Node{data: 5}; head.next = newNode

B. newNode := &Node{data: 5, next: head}; head = newNode

C. newNode := &Node{5}; head = newNode.next

D. newNode := Node{data: 5, next: nil}; head = newNode.next

Solution

1. Step 1: Create a new node with data and next pointer

   In Go, use &Node{data: 5, next: head} to create a new node pointing to current head.

2. Step 2: Update head to new node

   Assign head = newNode to make newNode the new head of the list.

3. Final Answer:

   newNode := &Node{data: 5, next: head}; head = newNode -> Option B

4. Quick Check:

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

Hint: New node's next points to head, then head updated [OK]

Common Mistakes:

• Not using pointer (&) for new node
• Assigning head.next instead of head
• Setting next to nil instead of head

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

type Node struct {
  data int
  next *Node
}

func main() {
  var head *Node = nil
  head = &Node{data: 1, next: head}
  head = &Node{data: 2, next: head}
  head = &Node{data: 3, next: head}
  printList(head)
}

func printList(node *Node) {
  for node != nil {
    fmt.Print(node.data, " -> ")
    node = node.next
  }
  fmt.Print("null")
}

medium

A. 3 -> 2 -> 1 -> null

B. 1 -> 2 -> 3 -> null

C. null

D. 1 -> null

Solution

1. Step 1: Trace node insertions

   First node with data 1 is pushed, head points to node 1.
   Then node 2 is pushed, head points to node 2, next points to node 1.
   Then node 3 is pushed, head points to node 3, next points to node 2.

2. Step 2: Print list from head

   Prints 3 -> 2 -> 1 -> null as nodes are added at front.

3. Final Answer:

   3 -> 2 -> 1 -> null -> Option A

4. Quick Check:

   Push adds at head, so list reversed [OK]

Hint: Push adds at head, so last pushed is first in list [OK]

Common Mistakes:

• Assuming push adds at tail
• Confusing order of nodes
• Ignoring nil termination

4. Identify the error in this Go code that tries to push a new node onto a linked list:

type Node struct {
  data int
  next *Node
}

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

func main() {
  var head *Node = nil
  push(head, 10)
  // printList(head) expected to show 10 -> null
}

medium

A. head is passed by value, so main's head is not updated

B. newNode is not created correctly with & operator

C. next pointer should be nil, not head

D. Function push should return void, not update head

Solution

1. Step 1: Analyze parameter passing

   head is passed by value to push, so changes inside push do not affect main's head.

2. Step 2: Effect on linked list head

   Assigning head = newNode inside push only changes local copy, main's head remains nil.

3. Final Answer:

   head is passed by value, so main's head is not updated -> Option A

4. Quick Check:

   Pointer must be passed by reference or returned [OK]

Hint: Pass head pointer by reference or return new head [OK]

Common Mistakes:

• Assuming pointer changes reflect outside function
• Not returning updated head
• Misunderstanding Go parameter passing

5. Given a linked list with nodes containing integers, how would you modify the push function to avoid memory leaks and ensure the list is correctly updated in Go?

hard

A. Use a slice instead of linked list for better memory management

B. Use a global variable for head instead of passing it

C. Make push return the new head node and assign it to head in main

D. Set newNode.next to nil before assigning head

Solution

1. Step 1: Understand pointer update requirement

   In Go, to update head outside push, function must return new head node.

2. Step 2: Assign returned head in main

   Call head = push(head, data) to update head correctly and avoid dangling pointers.

3. Final Answer:

   Make push return the new head node and assign it to head in main -> Option C

4. Quick Check:

   Return new head to update list safely [OK]

Hint: Return new head from push and assign it outside [OK]

Common Mistakes:

• Not returning updated head
• Using global variables unnecessarily
• Ignoring pointer semantics in Go