Push Using Linked List Node in DSA Go

Mental Model

Adding a new item at the start of a linked list means making the new item point to the current first item, then updating the start to this new item.

Analogy: Imagine a line of people holding hands. To add a new person at the front, the new person grabs the hand of the first person, then becomes the new leader of the line.

head -> 1 -> 2 -> 3 -> null
newNode (value=0)

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, push value 0

Goal: Add a new node with value 0 at the start of the list

Step 1: Create new node with value 0

head -> 1 -> 2 -> 3 -> null
newNode(0)

Why: We need a new node to add to the list

Step 2: Set new node's next pointer to current head (node with value 1)

newNode(0) -> 1 -> 2 -> 3 -> null

Why: New node must point to the old first node to keep the list connected

Step 3: Update head to point to new node

head -> 0 -> 1 -> 2 -> 3 -> null

Why: Head must point to new node because it is now the first node

Result:

head -> 0 -> 1 -> 2 -> 3 -> null

Annotated Code

DSA Go

package main

import "fmt"

type Node struct {
	value int
	next  *Node
}

type LinkedList struct {
	head *Node
}

// Push adds a new node with given value at the start of the list
func (ll *LinkedList) Push(val int) {
	newNode := &Node{value: val}
	newNode.next = ll.head // link new node to current head
	ll.head = newNode      // update head to new node
}

// PrintList prints the linked list values
func (ll *LinkedList) PrintList() {
	curr := ll.head
	for curr != nil {
		fmt.Printf("%d -> ", curr.value)
		curr = curr.next
	}
	fmt.Println("null")
}

func main() {
	ll := LinkedList{}
	// Create initial list 1 -> 2 -> 3 -> null
	ll.Push(3)
	ll.Push(2)
	ll.Push(1)

	// Push 0 at start
	ll.Push(0)

	ll.PrintList()
}

newNode := &Node{value: val}

create new node with given value

newNode.next = ll.head // link new node to current head

point new node's next to current head to keep list connected

ll.head = newNode // update head to new node

update head pointer to new node, making it first in list

Output

0 -> 1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change a few pointers without traversing the list

Space: O(1) because we only create one new node regardless of list size

vs Alternative: Compared to adding at the end which requires O(n) traversal, pushing at start is faster and simpler

Edge Cases

empty list (head is nil)

new node becomes the head and points to nil

DSA Go

ll.head = newNode      // update head to new node

When to Use This Pattern

When you need to add an item quickly at the start of a list, use the push pattern to insert in constant time by updating head pointer.

Common Mistakes

Mistake: Forgetting to update the head pointer to the new node after linking
Fix: Always assign head to new node after setting newNode.next to old head

Mistake: Setting newNode.next to nil instead of current head
Fix: Set newNode.next = head to keep the list connected

Summary

Adds a new node at the beginning of a linked list by updating pointers.

Use when you want to insert quickly at the start without traversing the list.

The new node points to the old head, then head updates to new node.

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