Delete Node at Beginning in DSA Java - Execution Trace

Concept Flow - Delete Node at Beginning

Start with head node

↓

Check if list is empty

↓

Move head to next node

↓

Old head node removed

↓

Updated list with new head

This flow shows how we remove the first node by moving the head pointer to the next node if the list is not empty.

Execution Sample

DSA Java

class Node {
  int data;
  Node next;
  Node(int data) {
    this.data = data;
  }
}

Node head = new Node(1);
head.next = new Node(2);
if (head != null) {
  head = head.next;
} // delete first node

This code deletes the first node by moving the head pointer to the next node.

Execution Table

Step	head.data	head.next.data	Action	List State
1	1	2	Start with head at node 1	1 -> 2 -> null
2	1	2	Check if list is empty (head != null)	1 -> 2 -> null
3	2	null	Move head to next node (head = head.next)	2 -> null
4	2	null	Old head node removed, list updated	2 -> null
5	null	N/A	If head was null, no deletion	List empty

💡 Execution stops after head moves to next node or if list is empty (head == null)

Variable Tracker

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

Key Moments - 2 Insights

Why do we check if the list is empty before deleting?

Because if head is null (empty list), there is no node to delete. This is shown in execution_table row 2 where we check head != null.

What happens to the old first node after deletion?

The old first node is no longer referenced by head, so it is removed from the list. This is shown in execution_table row 4 where head points to the second node.

Visual Quiz - 3 Questions

Look at the execution table, what is head.data after step 3?

A 2

B 1

C null

D 3

💡 Hint

Check the 'head.data' column in execution_table row 3.

At which step does the list become '2 -> null'?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'List State' column in execution_table rows.

If the list was empty initially, what would happen?

A An error occurs

B head moves to next node

C Nothing happens, no deletion

D A new node is added

💡 Hint

Refer to execution_table row 5 where head is null.

Concept Snapshot

Delete Node at Beginning:
- Check if list is empty (head == null)
- If not empty, move head to head.next
- Old first node is removed
- Updated list starts from new head
- Safe to delete only if list not empty

Full Transcript

To delete the first node in a linked list, we start by checking if the list is empty by seeing if head is null. If the list is not empty, we move the head pointer to the next node. This effectively removes the first node from the list because no references point to it anymore. The list now starts from the second node. If the list was empty, no deletion happens. This process is simple and safe, ensuring we do not try to delete from an empty list.

Practice

1. What happens to the head pointer when you delete a node at the beginning of a singly linked list?

easy

A. It moves to the next node in the list

B. It becomes null immediately

C. It points to the last node

D. It remains unchanged

Solution

1. Step 1: Understand the head pointer role

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

2. Step 2: Effect of deleting the first node

   Deleting the first node means the head must point to the second node, which becomes the new first node.

3. Final Answer:

   It moves to the next node in the list -> Option A

4. Quick Check:

   Head points to next node after deletion [OK]

Hint: Head always points to first node; update it to next after deletion [OK]

Common Mistakes:

• Forgetting to update head pointer
• Setting head to null without checking list
• Pointing head to last node incorrectly

2. Which of the following is the correct syntax to delete the first node in a singly linked list in Java?

easy

A. head = head.next;

B. head.next = head;

C. head = null.next;

D. head.next = null;

Solution

1. Step 1: Understand the head pointer update

   To delete the first node, head must point to the second node, which is head.next.

2. Step 2: Check each option

   head = head.next; correctly assigns head to head.next. Others either cause errors or wrong assignments.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   Assign head to next node to delete first [OK]

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

Common Mistakes:

• Using head.next = head which reverses links
• Trying to access null.next causing error
• Setting head.next to null which breaks list

3. Given the linked list: 10 -> 20 -> 30 -> null, what will be the list after deleting the node at the beginning using head = head.next;?

medium

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

B. 20 -> 30 -> null

C. 30 -> null

D. null

Solution

1. Step 1: Identify the initial list

   The list starts as 10 -> 20 -> 30 -> null, with head pointing to 10.

2. Step 2: Apply deletion by moving head

   Setting head = head.next moves head to 20, so the list becomes 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option B

4. Quick Check:

   Head moves from 10 to 20 after deletion [OK]

Hint: After deletion, head points to second node, list starts there [OK]

Common Mistakes:

• Not updating head pointer
• Assuming first node remains
• Confusing node values after deletion

4. What is wrong with this code snippet for deleting the first node in a singly linked list?

if (head == null) {
    System.out.println("List is empty");
} else {
    head.next = head;
}

medium

A. It correctly deletes the first node

B. It throws a NullPointerException

C. It sets head to null, losing the list

D. It causes the head to point to itself, creating a cycle

Solution

1. Step 1: Analyze the assignment head.next = head

   This sets the next pointer of the first node to point back to itself, creating a cycle.

2. Step 2: Understand the impact on deletion

   The head pointer is not updated, so the first node is not removed and the list structure is broken.

3. Final Answer:

   It causes the head to point to itself, creating a cycle -> Option D

4. Quick Check:

   Incorrect pointer assignment creates cycle [OK]

Hint: Assign head = head.next to delete; avoid head.next = head [OK]

Common Mistakes:

• Confusing head.next = head with head = head.next
• Not checking for empty list before deletion
• Ignoring pointer updates causing cycles

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> 35 -> null. After deleting the first node twice using head = head.next;, what will be the final list?

hard

A. 35 -> null

B. 15 -> 25 -> 35 -> null

C. 25 -> 35 -> null

D. null

Solution

1. Step 1: Initial list and first deletion

   Start: 5 -> 15 -> 25 -> 35 -> null. After first deletion, head moves to 15, list is 15 -> 25 -> 35 -> null.

2. Step 2: Second deletion

   After second deletion, head moves to 25, list is 25 -> 35 -> null.

3. Final Answer:

   25 -> 35 -> null -> Option C

4. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head to next node, removing first node [OK]

Common Mistakes:

• Deleting only once instead of twice
• Confusing node values after multiple deletions
• Not updating head pointer correctly each time