Insert at Beginning Head Insert in DSA Python - Execution Trace

Concept Flow - Insert at Beginning Head Insert

Create new node

↓

New node.next = head

↓

head = new node

↓

Done

Insert a new node by making it point to the current head, then update head to this new node.

Execution Sample

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

head = None
# Insert 10 at beginning
new_node = Node(10)
new_node.next = head
head = new_node

This code inserts a new node with value 10 at the beginning of an empty linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Start with empty list	None	head = None	List is empty
2	Create new node with data=10	Node(10)	new_node created, next=None	┌────────┐ │ data:10│ │ next:∅ │ └────────┘
3	Set new_node.next = head (None)	Node(10)	new_node.next = None	┌────────┐ │ data:10│ │ next:∅ │ └────────┘
4	Update head = new_node	Node(10)	head → new_node	┌────────┐ │ data:10│ │ next:∅ │ └────────┘ head
5	Insert 20 at beginning	Node(20) → Node(10)	new_node created, new_node.next = head, head = new_node	BEFORE: ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ next:∅ │ │ next:∅ │ └────────┘ └────────┘ head Step 1: new_node.next = head Step 2: head = new_node AFTER: ┌────────┐ ┌────────┐ │ data:20│ ──→ │ data:10│ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ head
6	Insert 30 at beginning	Node(30) → Node(20) → Node(10)	new_node created, new_node.next = head, head = new_node	BEFORE: ┌────────┐ ┌────────┐ ┌────────┐ │ data:20│ ──→ │ data:10│ │ data:30│ │ next:──┼──→ │ next:∅ │ │ next:∅ │ └────────┘ └────────┘ └────────┘ head Step 1: new_node.next = head Step 2: head = new_node AFTER: ┌────────┐ ┌────────┐ ┌────────┐ │ data:30│ ──→ │ data:20│ ──→ │ data:10│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head
7	End of insertions	Node(30) → Node(20) → Node(10)	No changes	Final list: ┌────────┐ ┌────────┐ ┌────────┐ │ data:30│ ──→ │ data:20│ ──→ │ data:10│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head

💡 No more insertions, list head points to newest node.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	After Step 6	Final
head	None	None	Node(10)	Node(20)	Node(30)	Node(30)
new_node	None	Node(10)	Node(10)	Node(20)	Node(30)	Node(30)

Key Moments - 3 Insights

Why do we set new_node.next = head before updating head?

Because new_node.next must point to the old first node to keep the list connected. See execution_table step 3 and 4 where new_node.next is set before head changes.

What happens if the list is empty when inserting?

The new node's next points to None (empty list), and head points to the new node. See execution_table steps 1 to 4 for empty list insertion.

Why does head always point to the newest inserted node?

Because we update head = new_node after linking new_node.next to old head. This makes the new node the first in the list. See execution_table steps 4, 5, and 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what does head point to?

A Node with data 20

B Node with data 10

C Node with data 30

D None

💡 Hint

Check the 'Pointer Changes' and 'Visual State' columns at step 5.

At which step does the list first contain more than one node?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the 'Nodes in List' column to see when multiple nodes appear.

If we skip setting new_node.next = head, what happens to the list?

A List becomes empty

B New node points to None, old list lost

C Head points to old first node

D No change in list

💡 Hint

Refer to the pointer changes in steps 3 and 4.

Concept Snapshot

Insert at Beginning (Head Insert):
- Create new node
- Set new_node.next = head
- Update head = new_node
- New node becomes first element
- Works for empty and non-empty lists

Full Transcript

To insert at the beginning of a linked list, first create a new node. Then, link this new node's next pointer to the current head of the list. Finally, update the head pointer to this new node. This makes the new node the first element. If the list was empty, the new node's next points to None. Each insertion updates head to the newest node, preserving the list order. The execution table shows step-by-step how nodes and pointers change, and the variable tracker follows head and new_node references. Key moments clarify why pointer updates happen in this order and what occurs when the list is empty.