Delete Node at Beginning in DSA Typescript - Execution Trace

Concept Flow - Delete Node at Beginning

Start with head node

↓

Check if head is null?

Yes→List is empty, nothing to delete

No↓

Move head pointer to next node

↓

Old head node is removed

↓

Return updated list

The flow checks if the list is empty. If not, it moves the head pointer to the next node, effectively removing the first node.

Execution Sample

DSA Typescript

class Node {
  constructor(public data: number, public next: Node | null = null) {}
}

let head = new Node(1, new Node(2, new Node(3)));
head = head.next; // Delete first node

This code deletes the first node of a linked list by moving the head pointer to the next node.

Execution Table

Step	head.data	head.next.data	Action	List State
1	1	2	Initial list head points to node with data 1	1 -> 2 -> 3 -> null
2	2	3	head = head.next; move head to next node	2 -> 3 -> null
3	2	3	Deletion complete, old head removed	2 -> 3 -> null
4	null	null	If head was null initially, no deletion	List empty

💡 head moves to next node or remains null if list empty, stopping deletion

Variable Tracker

Variable	Start	After Step 2	Final
head.data	1	2	2
head.next.data	2	3	3

Key Moments - 2 Insights

Why do we assign head = head.next to delete the first node?

Because head points to the first node, moving it to head.next skips the first node, effectively removing it from the list as shown in execution_table step 2.

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

No deletion occurs because the check at step 1 in the concept_flow and execution_table step 4 shows that if head is null, we do nothing.

Visual Quiz - 3 Questions

Look at the execution_table, what is head.data after step 2?

A 2

B 1

C 3

D null

💡 Hint

Refer to execution_table row with Step 2 under head.data column

At which step does the list state change from '1 -> 2 -> 3 -> null' to '2 -> 3 -> null'?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Check the List State column in execution_table for the change

If the list was empty initially, what would be the value of head after deletion attempt?

A Node with data 1

B Node with data 2

C null

D Node with data 3

💡 Hint

See execution_table step 4 where head is null if list empty

Concept Snapshot

Delete Node at Beginning:
- Check if head is null (empty list)
- If not, move head to head.next
- Old first node is removed
- Updated list starts from new head
- Simple pointer update removes first node

Full Transcript

To delete the first node in a linked list, we check if the list is empty by seeing if head is null. If it is not empty, we move the head pointer to the next node. This skips the first node, effectively deleting it. The old first node is no longer referenced and is removed from the list. If the list is empty, no deletion happens. This is shown step-by-step in the execution table where the list changes from 1 -> 2 -> 3 to 2 -> 3 after deletion.

Practice

1. What happens when you delete the first node in a singly linked list?

easy

A. The head pointer moves to the second node

B. The last node is deleted

C. The list becomes empty immediately

D. The middle node is removed

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Delete the first node by moving head

   Deleting the first node means moving the head pointer to the next node.

3. Final Answer:

   The head pointer moves to the second node -> Option A

4. Quick Check:

   Delete first node = move head to next [OK]

Hint: Deleting first node means moving head to next node [OK]

Common Mistakes:

• Thinking the last node is deleted
• Assuming list becomes empty always
• Deleting a middle node instead

2. Which of the following is the correct TypeScript syntax to delete the first node in a singly linked list with head pointer head?

easy

A. head = head.next;

B. head.next = head;

C. delete head;

D. head = null.next;

Solution

1. Step 1: Understand head and next pointers

   head points to first node; head.next points to second node.

2. Step 2: Assign head to head.next to delete first node

   Setting head = head.next moves head to second node, effectively deleting first.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   Correct syntax to delete first node = head = head.next; [OK]

Hint: Use head = head.next to delete first node [OK]

Common Mistakes:

• Using delete keyword incorrectly
• Assigning head.next to head
• Accessing null.next causing error

3. Given the linked list: 1 -> 2 -> 3 -> null and the code snippet:

head = head.next;

What is the resulting linked list?

medium

A. 1 -> 2 -> 3 -> null

B. 2 -> 3 -> null

C. 3 -> null

D. null

Solution

1. Step 1: Initial list and head pointer

   Head points to node with value 1, list is 1 -> 2 -> 3 -> null.

2. Step 2: Move head to head.next

   head = head.next moves head to node with value 2, removing first node.

3. Final Answer:

   2 -> 3 -> null -> Option B

4. Quick Check:

   After deletion, list starts at 2 [OK]

Hint: After head = head.next, list starts from second node [OK]

Common Mistakes:

• Assuming list remains unchanged
• Thinking last node is deleted
• Confusing node values after deletion

4. Consider this TypeScript code to delete the first node:

if (head !== null) {
  head = head.next;
}

What error does this fix compared to just head = head.next;?

medium

A. Prevents deleting the last node

B. Prevents memory leak

C. Prevents runtime error if list is empty

D. Prevents deleting middle node

Solution

1. Step 1: Understand head could be null

   If list is empty, head is null and head.next causes error.

2. Step 2: Check head before accessing next

   Condition ensures head is not null before moving to head.next, avoiding runtime error.

3. Final Answer:

   Prevents runtime error if list is empty -> Option C

4. Quick Check:

   Check head != null before head.next avoids error [OK]

Hint: Check head not null before deleting first node [OK]

Common Mistakes:

• Ignoring null head causing crash
• Thinking it prevents memory leaks
• Confusing node positions deleted

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40 -> null. You want to delete the first two nodes safely. Which code snippet correctly does this?

hard

A. head = null;

B. head = head.next; head = head.next;

C. head.next = head.next.next;

D. if (head && head.next) { head = head.next.next; }

Solution

1. Step 1: Understand deleting two nodes means moving head twice

   Deleting first two nodes means head should point to third node.

2. Step 2: Check head and head.next exist before moving head twice

   Condition ensures no runtime error when accessing head.next.next.

3. Final Answer:

   if (head && head.next) { head = head.next.next; } -> Option D

4. Quick Check:

   Check head and head.next before double move [OK]

Hint: Check head and head.next before skipping two nodes [OK]

Common Mistakes:

• Not checking head.next causing error
• Assigning head.next instead of head
• Setting head to null deletes entire list