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, pointing it to the current head, then updating head to this new node.

Execution Sample

DSA C#

Node newNode = new Node(5);
newNode.next = head;
head = newNode;

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	10 -> 20 -> 30 -> null	newNode created with data=5, next=null	┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head
2	Set newNode.next = head	10 -> 20 -> 30 -> null (newNode not yet in list)	newNode.next points to node with data=10	newNode: ┌────────┐ │ data:5 │ │ next:──┼──→ head (data:10) └────────┘ List unchanged: ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head
3	Update head = newNode	5 -> 10 -> 20 -> 30 -> null	head now points to newNode	┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ data:5 │ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ └────────┘ head
4	Done	5 -> 10 -> 20 -> 30 -> null	No pointer changes	Final list: ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ data:5 │ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:──┼──→ │ 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 node with data=10	points to node with data=10	points to node with data=10	points to newNode (data=5)	points to newNode (data=5)
newNode	null	new node created with data=5, next=null	next points to head (data=10)	exists with next=head	exists with next=head

Key Moments - 3 Insights

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

Because if we update head first, we lose reference to the old list. Setting newNode.next = head keeps the old list connected. See execution_table step 2 and 3.

What happens if the list is empty (head is null)?

newNode.next will be set to null (the current head), so the new node becomes the only node. This is shown in the pointer change where newNode.next points to head, even if head is null.

Why does head point to newNode after insertion?

Because the new node is now the first node in the list. Updating head to newNode makes it the entry point to the list. See execution_table step 3.

Visual Quiz - 3 Questions

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

A Node with data=10

B Node with data=5

C Null

D Node with data=30

💡 Hint

Check 'Pointer Changes' column at step 2 in execution_table

At which step does the linked list visually include the new node at the beginning?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at 'Visual State' column to see when newNode is linked as head

If head was null initially, what would newNode.next be after step 2?

A Points to node with data=10

B Points to null

C Points to node with data=5

D Undefined

💡 Hint

Refer to variable_tracker and explanation in key_moments about empty list

Concept Snapshot

Insert at Beginning (Head Insert):
1. Create new node with data.
2. Set newNode.next = current head.
3. Update head = newNode.
Result: new node is first, old list follows.
Works even if list is empty (head=null).

Full Transcript

To insert a node at the beginning of a linked list, first create the new node. Then point its next to the current head node. Finally, update the head pointer to this new node. This way, the new node becomes the first node, and the old list remains connected after it. If the list was empty, the new node's next points to null, making it the only node. This process is shown step-by-step in the execution table and pointer diagrams.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Deletes the last node of the list

B. Adds a new node at the start of the list

C. Deletes the first node of the list

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

Solution

1. Step 1: Understand the operation

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

2. Step 2: Effect on the list

   The new node becomes the head, pushing existing nodes after it.

3. Final Answer:

   Adds a new node at the start of the list -> Option B

4. Quick Check:

   Insert at beginning = Add new head [OK]

Hint: New node becomes head, old head moves next [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it changes the tail node

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. new Node(data).next = head; head = new Node(data);

B. head = new Node(data); head.next = oldHead;

C. head.next = new Node(data);

D. Node newNode = new Node(data); newNode.next = head; head = newNode;

Solution

1. Step 1: Create new node and link

   Create a new node and set its next pointer to current head.

2. Step 2: Update head pointer

   Assign head to the new node to make it the first node.

3. Final Answer:

   Node newNode = new Node(data); newNode.next = head; head = newNode; -> Option D

4. Quick Check:

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

Hint: New node next = head; head = new node [OK]

Common Mistakes:

• Not updating head after creating new node
• Assigning head before setting newNode.next
• Creating multiple new nodes unnecessarily

3. What will be the output of the following code snippet?

class Node {
  public int data;
  public Node next;
  public Node(int d) { data = d; next = null; }
}

Node head = new Node(10);
head.next = new Node(20);
Node newNode = new Node(5);
newNode.next = head;
head = newNode;

Node temp = head;
while(temp != null) {
  Console.Write(temp.data + " -> ");
  temp = temp.next;
}
Console.WriteLine("null");

medium

A. 5 -> 10 -> 20 -> null

B. 20 -> 10 -> 5 -> null

C. 10 -> 20 -> 5 -> null

D. 5 -> 20 -> 10 -> null

Solution

1. Step 1: Initial list creation

   Head points to 10, which points to 20 (10 -> 20 -> null).

2. Step 2: Insert new node at beginning

   New node with data 5 points to old head (10), then head updated to new node (5).

3. Step 3: Traverse and print list

   Traversal prints 5 -> 10 -> 20 -> null.

4. Final Answer:

   5 -> 10 -> 20 -> null -> Option A

5. Quick Check:

   New head 5, followed by 10 and 20 [OK]

Hint: New node points to old head, becomes new head [OK]

Common Mistakes:

• Confusing order of nodes after insertion
• Not updating head pointer
• Printing nodes before insertion

4. Identify the error in the following code that tries to insert a node at the beginning of a singly linked list:

Node newNode = new Node(15);
newNode.next = newNode;
head = newNode;

medium

A. head should be assigned before setting newNode.next

B. Node constructor is missing data parameter

C. newNode.next should point to head, not newNode

D. No error, code is correct

Solution

1. Step 1: Analyze newNode.next assignment

   newNode.next points to itself, creating a cycle instead of linking to the list.

2. Step 2: Correct pointer assignment

   newNode.next should point to current head to insert at beginning properly.

3. Final Answer:

   newNode.next should point to head, not newNode -> Option C

4. Quick Check:

   Link new node to old head, not itself [OK]

Hint: newNode.next = head, not newNode [OK]

Common Mistakes:

• Setting next pointer to newNode itself
• Not updating head after insertion
• Confusing order of assignments

5. You have a singly linked list with nodes containing values [30, 40, 50]. You want to insert nodes with values [10, 20] at the beginning in that order so the final list is [10, 20, 30, 40, 50]. Which sequence of insertions achieves this?

hard

A. Insert 20 at beginning, then insert 10 at beginning

B. Insert 10 at beginning, then insert 20 at beginning

C. Insert 10 at end, then insert 20 at beginning

D. Insert 20 at end, then insert 10 at beginning

Solution

1. Step 1: Understand insertion order effect

   Each insert at beginning places new node before current head.

2. Step 2: Insert 10 first, then 20

   Inserting 10 first results in list [10, 30, 40, 50]. Then inserting 20 at beginning results in [20, 10, 30, 40, 50].

3. Step 3: Reverse the order to get desired list

   To get [10, 20, 30, 40, 50], insert 20 first, then 10.

4. Final Answer:

   Insert 20 at beginning, then insert 10 at beginning -> Option A

5. Quick Check:

   Last inserted node becomes new head [OK]

Hint: Insert last value first to keep order at head [OK]

Common Mistakes:

• Inserting in given order causes reversed nodes
• Confusing insert at beginning with insert at end
• Not updating head after each insertion