Delete Node at Beginning in DSA Typescript - 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 delete the first node from an empty linked list?

Nothing changes because the list is already empty; no nodes to delete.

intermediate

Show the TypeScript code snippet to delete the first node in a singly linked list.

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

beginner

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

O(1) because it only requires updating the head pointer once.

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

A Tail pointer

B Head pointer

C Next pointer of the 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 a list with only one node?

A Tail pointer changes

B Head points to itself

C Head becomes null

D List becomes circular

After deleting the only node, the list becomes empty, so head becomes null.

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

A O(1)

B O(log n)

C O(n^2)

D O(n)

Deleting the first node requires only one pointer update, so it is O(1).

If the linked list is empty, what should happen when deleting the first node?

A Do nothing

B Throw an error

C Create a new node

D Set head to a new node

If the list is empty, there is no node to delete, so the operation does nothing.

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

A this.tail = null;

B this.tail = this.tail.next;

C this.head.next = null;

D this.head = this.head.next;

To delete the first node, update head to point to the next node.

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

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

Write a simple TypeScript function to delete the first node of a singly linked list and describe its time complexity.

Focus on pointer update and constant time operation.

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