Insert at Beginning Head Insert in DSA C++ - Execution Trace

Concept Flow - Insert at Beginning Head Insert

Create new node

↓

Set new_node->next = head

↓

Update head = new_node

↓

Done

Insert a new node by creating it, linking it to the current head, then updating head to the new node.

Execution Sample

DSA C++

Node* new_node = new Node(5);
new_node->next = head;
head = new_node;

Insert a new node with value 5 at the beginning of the linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with data=5	∅ (empty list)	new_node created, next=∅	∅
2	Set new_node.next = head (which is ∅)	∅	new_node.next → ∅	new_node(data:5, next:∅)
3	Update head = new_node	5 → ∅	head → new_node	┌────────┐ │ data:5 │ │ next:∅ │ └────────┘ head
4	End of insertion	5 → ∅	head points to new node	┌────────┐ │ data:5 │ │ next:∅ │ └────────┘ head

💡 Insertion complete, head updated to new node with data 5

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
head	∅	∅	∅	points to new_node	points to new_node
new_node	N/A	node(5, next:∅)	node(5, next:∅)	node(5, next:∅)	node(5, next:∅)

Key Moments - 3 Insights

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

Because we want the new node to point to the current first node before head changes. See execution_table step 2 where new_node.next links to old head.

What happens if the list is empty before insertion?

Head is null (∅), so new_node.next is set to ∅, making the new node the only node. See execution_table step 1 and 2.

Why does head point to new_node after insertion?

Because the new node is now the first node in the list. This is shown in execution_table step 3 where head updates to new_node.

Visual Quiz - 3 Questions

Look at the execution table, what does head point to after step 3?

A Null (empty list)

B The old head node

C The new node with data 5

D A node with data 0

💡 Hint

Check execution_table row with Step 3 under Pointer Changes and Visual State

At which step is new_node.next set to point to the old head?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table rows and find where new_node.next is assigned

If the list was not empty, how would the visual state change after step 3?

A new_node points to the old first node, head points to new_node

B head points to null, new_node is isolated

C new_node.next is null, head unchanged

D head points to old node, new_node is lost

💡 Hint

Refer to concept_flow and execution_table steps showing pointer updates

Concept Snapshot

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

Full Transcript

To insert a node at the beginning of a linked list, first create the new node with the desired data. Then set the new node's next pointer to the current head of the list. Finally, update the head pointer to the new node. This makes the new node the first node in the list. If the list was empty, the new node's next points to null. The execution table shows each step with pointer changes and the visual state of the list. The variable tracker shows how head and new_node change during the process. Key moments clarify why the order of pointer updates matters and what happens when the list is empty.

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. Deletes the first node of the list

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

D. Searches for a node at the beginning

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means placing a new node before the current head.

2. Step 2: Effect on the list

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

3. Final Answer:

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

4. Quick Check:

   Insert at beginning = new head [OK]

Hint: New node always becomes the head in beginning insert [OK]

Common Mistakes:

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

2. Which of the following is the correct syntax to insert a new node at the beginning of a singly linked list in C++?

easy

A. head->next = newNode; newNode = head;

B. newNode->next = head; head = newNode;

C. head = newNode; newNode->next = head;

D. newNode = head; head = newNode->next;

Solution

1. Step 1: Link new node to current head

   Set newNode->next to point to the current head node.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the new first node.

3. Final Answer:

   newNode->next = head; head = newNode; -> Option B

4. Quick Check:

   Link then update head [OK]

Hint: Set newNode->next first, then update head [OK]

Common Mistakes:

• Updating head before linking newNode->next
• Swapping pointers incorrectly
• Assigning newNode to head->next

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

struct Node { int data; Node* next; };
Node* head = nullptr;
Node* newNode = new Node{10, nullptr};
newNode->next = head;
head = newNode;
newNode = new Node{20, nullptr};
newNode->next = head;
head = newNode;

Print the list from head to end.

medium

A. 20 -> 10 -> null

B. 10 -> 20 -> null

C. null -> 10 -> 20

D. 10 -> null

Solution

1. Step 1: Insert first node with data 10

   head points to node with 10, next is nullptr.

2. Step 2: Insert second node with data 20 at beginning

   newNode->next = head (node 10), head = newNode (node 20).

3. Final Answer:

   20 -> 10 -> null -> Option A

4. Quick Check:

   Last inserted node is head [OK]

Hint: Last inserted node is always head [OK]

Common Mistakes:

• Assuming order is insertion order instead of reversed
• Confusing next pointers
• Ignoring nullptr termination

4. Identify the error in this code snippet for inserting at the beginning of a linked list:

Node* newNode = new Node();
newNode->data = 5;
head = newNode;
newNode->next = head;

medium

A. No error, code is correct

B. newNode->data is not initialized

C. head should be set to nullptr first

D. newNode->next should be assigned before head is updated

Solution

1. Step 1: Check pointer assignments order

   Assigning head = newNode before setting newNode->next causes newNode->next to point to itself.

2. Step 2: Correct order

   newNode->next should be set to current head before updating head to newNode.

3. Final Answer:

   newNode->next should be assigned before head is updated -> Option D

4. Quick Check:

   Link newNode->next before head update [OK]

Hint: Always link newNode->next before changing head [OK]

Common Mistakes:

• Updating head before linking newNode->next
• Forgetting to initialize newNode->data
• Assuming no error in pointer assignments

5. Given a linked list with nodes 30 -> 20 -> 10 -> null, what will be the list after inserting a new node with data 40 at the beginning twice in a row?

hard

A. 40 -> 40 -> 30 -> 20 -> 10 -> null

B. 30 -> 20 -> 10 -> 40 -> 40 -> null

C. 40 -> 30 -> 20 -> 10 -> null

D. 40 -> 30 -> 20 -> 10 -> 40 -> null

Solution

1. Step 1: Insert first 40 at beginning

   New head is 40, next points to old head 30.

2. Step 2: Insert second 40 at beginning

   New head is another 40, next points to previous 40 node.

3. Final Answer:

   40 -> 40 -> 30 -> 20 -> 10 -> null -> Option A

4. Quick Check:

   Each insert adds new head [OK]

Hint: Each insert adds a new head node [OK]

Common Mistakes:

• Assuming duplicate nodes merge
• Inserting at end instead of beginning
• Losing track of next pointers