Delete Node at Beginning in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Delete Node at Beginning' mean in a linked list?

It means removing the first node of the linked list and making the second node the new head.

beginner

Why do we need to update the head pointer when deleting the first node?

Because the head points to the first node, and after deletion, the head must point to the new first node to keep the list connected.

beginner

What happens if we try to delete a node at the beginning when the list is empty?

Nothing changes because there is no node to delete; the list remains empty.

beginner

Show the Java code snippet to delete the first node of a singly linked list.

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

beginner

What is the time complexity of deleting a node at the beginning of a singly linked list?

O(1) because it only involves changing the head pointer to the next node.

What pointer do you update when deleting the first node of a singly linked list?

A Head pointer

B Tail pointer

C Next pointer of last node

D Previous pointer

The head pointer must be updated to point to the second node after deleting the first node.

What happens if you delete the first node in an empty linked list?

A New node is created

B List becomes empty

C Tail pointer changes

D Error or no change

Since the list is empty, there is no node to delete, so no change occurs.

What is the time complexity of deleting the first node in a singly linked list?

A O(n)

B O(1)

C O(log n)

D O(n^2)

Deleting the first node is done by updating the head pointer, which takes constant time O(1).

Which of these is the correct Java code to delete the first node?

A head = head.next;

B head.next = head;

C head = null.next;

D head.next = null;

Assigning head to head.next moves the head pointer to the second node, effectively deleting the first.

After deleting the first node, what does the new head point to?

A The old first node

B Null always

C The second node

D The last node

The new head points to the second node, which becomes the first node after deletion.

Explain step-by-step how to delete the first node in a singly linked list.

Think about what the head pointer points to before and after deletion.

Describe what happens to the linked list structure when the first node is deleted.

Focus on the pointers and how the list nodes connect.

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