Delete Node at Beginning in DSA C - 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 updating the head pointer to the next node.

beginner

What happens to the head pointer when you delete the first node in a linked list?

The head pointer is updated to point to the second node in the list, which becomes the new first node.

intermediate

Why is it important to free the deleted node in C after deleting it from the linked list?

To release the memory allocated to that node and avoid memory leaks in the program.

beginner

What should you check before deleting the first node in a linked list?

You should check if the list is empty (head is NULL) to avoid errors when deleting.

beginner

In C, which function is used to free the memory of a deleted node?

The free() function is used to release the memory allocated to the node.

What is the first step when deleting the first node of a linked list?

A Create a new node

B Free the last node

C Update head to point to the next node

D Traverse to the end of the list

The head pointer must be updated to the second node before freeing the first node.

What should you do if the linked list is empty when trying to delete the first node?

A Create a new node

B Do nothing or return immediately

C Free the head pointer

D Set head to NULL

If the list is empty (head is NULL), there is no node to delete.

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

A The second node

B The deleted node

C NULL always

D The last node

The head pointer moves to the second node, which becomes the new first node.

Which C function is used to release memory of a deleted node?

A scanf()

B malloc()

C printf()

D free()

free() releases allocated memory to avoid leaks.

What happens if you forget to free the deleted node's memory?

A Memory leak occurs

B Program crashes immediately

C Node is deleted automatically

D Nothing happens

Not freeing memory causes memory leaks, wasting resources.

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

Think about what happens to the head pointer and memory.

Why is it important to update the head pointer before freeing the first node?

Consider what happens if head is freed first.

Practice

1. What happens to the linked list when you delete the node at the beginning?

easy

A. All nodes are deleted at once.

B. The last node is deleted instead of the first.

C. The list remains unchanged.

D. The head pointer moves to the next node, removing the first node.

Solution

1. Step 1: Understand the head pointer role

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

2. Step 2: Effect of deleting the first node

   Deleting the first node means moving the head pointer to the second node, effectively removing the first node from the list.

3. Final Answer:

   The head pointer moves to the next node, removing the first node. -> Option D

4. Quick Check:

   Deleting at beginning means head moves forward [OK]

Hint: Deleting at start moves head to next node [OK]

Common Mistakes:

• Thinking the last node is deleted
• Assuming the list stays the same
• Deleting all nodes instead of one

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

easy

A. temp = head; head = head->next; free(temp);

B. head = head->next; free(head);

C. free(head); head = head->next;

D. head->next = NULL; free(head);

Solution

1. Step 1: Store current head in temp

   We save the current head node in a temporary pointer to free it later.

2. Step 2: Move head to next node and free old head

   Update head to point to the next node, then free the old head stored in temp.

3. Final Answer:

   temp = head; head = head->next; free(temp); -> Option A

4. Quick Check:

   Save old head, move head, free old [OK]

Hint: Save old head before moving and freeing [OK]

Common Mistakes:

• Freeing head before moving pointer
• Not saving old head before moving
• Setting next to NULL incorrectly

3. What will be the output linked list after deleting the first node from the list: 10 -> 20 -> 30 -> NULL?

medium

A. 10 -> 20 -> 30 -> NULL

B. NULL

C. 20 -> 30 -> NULL

D. 30 -> NULL

Solution

1. Step 1: Identify the first node

   The first node has value 10.

2. Step 2: Delete first node and move head

   After deletion, head points to node with value 20, so list starts from 20.

3. Final Answer:

   20 -> 30 -> NULL -> Option C

4. Quick Check:

   First node removed, next node becomes head [OK]

Hint: After deletion, list starts from second node [OK]

Common Mistakes:

• Not updating head pointer
• Deleting wrong node
• Assuming list becomes empty

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

struct Node* temp = head;
head = head->next;
free(head);

What is the error in this code?

medium

A. It frees the new head instead of the old head.

B. It does not update the head pointer.

C. It frees the temp pointer instead of head.

D. It causes a syntax error.

Solution

1. Step 1: Analyze pointer usage

   temp stores old head, head moves to next node.

2. Step 2: Identify which node is freed

   free(head) frees the new head, not the old node stored in temp, causing memory error.

3. Final Answer:

   It frees the new head instead of the old head. -> Option A

4. Quick Check:

   Free old node, not new head [OK]

Hint: Free the saved old head pointer, not the updated head [OK]

Common Mistakes:

• Freeing updated head instead of old node
• Not freeing any node causing memory leak
• Confusing temp and head pointers

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> 35 -> NULL. After deleting the first node twice, what will be the resulting list?

hard

A. 15 -> 25 -> 35 -> NULL

B. 25 -> 35 -> NULL

C. 35 -> NULL

D. NULL

Solution

1. Step 1: Delete first node once

   First deletion removes 5, list becomes 15 -> 25 -> 35 -> NULL.

2. Step 2: Delete first node again

   Second deletion removes 15, list becomes 25 -> 35 -> NULL.

3. Final Answer:

   25 -> 35 -> NULL -> Option B

4. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head forward by one node [OK]

Common Mistakes:

• Deleting only once instead of twice
• Confusing node values after deletion
• Assuming list becomes empty too soon