Insert at Head

Insert a new first node by pointing it at the old head and then moving the head pointer.

Algorithm

Basic Implementation

basic.go

package main

import (
	"fmt"
	"strings"
)

type Node struct {
	Value int
	Next  *Node
}

func render(head *Node) string {
	parts := []string{}
	for cursor := head; cursor != nil; cursor = cursor.Next {
		parts = append(parts, fmt.Sprint(cursor.Value))
	}
	return strings.Join(parts, " -> ") + " -> null"
}

func main() {
	head := &Node{20, &Node{30, nil}}
	newHead := &Node{10, nil}
	newHead.Next = head
	head = newHead
	fmt.Println(render(head))
}

Head insertion changes only two references: the new node points at the old head, then head moves to the new node.

Step 1 - Old first node

Before insertion, head points at node(20).

Step 2 - New node links to old head

Set new.next to the old first node before moving head.

Step 3 - Head moves to the new node

The final chain has 10 first: 10 -> 20 -> 30 -> null.

Complexity

Time: O(1)
Space: O(1)

Implementation notes

Keep the explicit node and pointer/reference operations; array shortcuts hide the linked-list state this lesson is meant to replay.
The final output prints the chain in a deterministic a -> b -> null form for cross-language comparison.

old head The previous first node becomes the second node.

constant-time insert Only the new node and head pointer change.