Delete Node at Beginning in DSA C

Mental Model

To remove the first item from a linked list, just move the start pointer to the next item and forget the old first one.

Analogy: Imagine a line of people holding hands. To remove the first person, you just let go of their hand and start holding the next person's hand instead.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3, delete node at beginning

Goal: Remove the first node and update the list to start from the second node

Step 1: store the current head node (1) to delete later

head -> [1] -> 2 -> 3 -> null

Why: We keep the first node temporarily to free its memory after updating head

Step 2: move head pointer to the next node (2)

head -> 2 -> 3 -> null

Why: This makes the second node the new first node in the list

Step 3: free the old first node (1)

head -> 2 -> 3 -> null

Why: We remove the old first node from memory to avoid leaks

Result:

head -> 2 -> 3 -> null

Annotated Code

DSA C

#include <stdio.h>
#include <stdlib.h>

// Node structure
struct Node {
    int data;
    struct Node* next;
};

// Function to print the list
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("null\n");
}

// Function to delete node at beginning
void deleteAtBeginning(struct Node** head_ref) {
    if (*head_ref == NULL) return; // empty list guard

    struct Node* temp = *head_ref; // store current head
    *head_ref = temp->next;        // move head to next node
    free(temp);                    // free old head
}

// Driver code
int main() {
    // Create list 1->2->3->null
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 1;
    head->next = malloc(sizeof(struct Node));
    head->next->data = 2;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->data = 3;
    head->next->next->next = NULL;

    printf("Original list:\n");
    printList(head);

    deleteAtBeginning(&head);

    printf("After deleting node at beginning:\n");
    printList(head);

    // Free remaining nodes
    while (head != NULL) {
        struct Node* temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}

if (*head_ref == NULL) return; // empty list guard

check if list is empty to avoid errors

struct Node* temp = *head_ref; // store current head

keep reference to old first node to free later

*head_ref = temp->next; // move head to next node

update head pointer to second node

free(temp); // free old head

release memory of removed node

Output

Original list:

1 -> 2 -> 3 -> null

After deleting node at beginning:

2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only update pointers once without traversing the list

Space: O(1) because no extra space is used besides a temporary pointer

vs Alternative: Compared to deleting at the end which requires O(n) traversal, deleting at beginning is faster and simpler

Edge Cases

empty list

function returns immediately without changes

DSA C

if (*head_ref == NULL) return; // empty list guard

single node list

head becomes NULL after deletion, list becomes empty

DSA C

*head_ref = temp->next;        // move head to next node

When to Use This Pattern

When you need to remove the first item from a linked list quickly, use the delete at beginning pattern because it only changes one pointer.

Common Mistakes

Mistake: Not updating the head pointer after deletion
Fix: Always assign head to head->next to move the start of the list

Mistake: Not checking if the list is empty before deleting
Fix: Add a guard to return immediately if head is NULL

Summary

Deletes the first node of a linked list by moving the head pointer to the next node.

Use when you want to remove the earliest element quickly without traversing the list.

The key is to update the head pointer and free the old first node to avoid memory leaks.

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