Delete Node by Value in DSA C - Build from Scratch

Delete Node by Value in a Linked List

📖 Scenario: You are managing a simple contact list stored as a linked list. Each node contains a contact's id and a pointer to the next contact. You want to remove a contact by their id.

🎯 Goal: Build a C program that creates a linked list of contacts, sets a target id to delete, deletes the node with that id, and prints the updated list.

📋 What You'll Learn

Create a linked list with exactly 4 nodes having id values 10, 20, 30, and 40 in that order

Create an integer variable target_id and set it to 30

Write a function deleteNodeByValue that deletes the node with id equal to target_id

Print the linked list after deletion in the format: 10 -> 20 -> 40 -> NULL

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like contact lists, music playlists, and undo history where items can be added or removed dynamically.

💼 Career

Understanding linked list operations like deletion is fundamental for software developers working with low-level data structures, embedded systems, or performance-critical applications.

1

Create the linked list with 4 nodes

Write code to create a linked list with 4 nodes having id values 10, 20, 30, and 40 in that order. Use a struct called Node with an int id and a Node* called next. Create a pointer head pointing to the first node.

DSA C

#include 
#include 

struct Node {
    int id;
    struct Node* next;
};

int main() {
    struct Node* head = NULL;

    // Create 4 nodes with ids 10, 20, 30, 40 and link them
    // Your code here

    return 0;
}

Hint

Use malloc to create each node and set the id and next pointers accordingly.

2

Set the target id to delete

Create an integer variable called target_id and set it to 30.

DSA C

#include 
#include 

struct Node {
    int id;
    struct Node* next;
};

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->id = 10;
    head->next = malloc(sizeof(struct Node));
    head->next->id = 20;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->id = 30;
    head->next->next->next = malloc(sizeof(struct Node));
    head->next->next->next->id = 40;
    head->next->next->next->next = NULL;

    // Create an int variable target_id and set it to 30
    // Your code here

    return 0;
}

Hint

Just declare int target_id = 30; inside main.

3

Write the function to delete node by value

Write a function called deleteNodeByValue that takes a pointer to the pointer head and an integer target_id. It deletes the first node with id equal to target_id from the linked list. Use variables temp and prev inside the function. Call this function from main with &head and target_id.

DSA C

#include 
#include 

struct Node {
    int id;
    struct Node* next;
};

// Write deleteNodeByValue function here

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->id = 10;
    head->next = malloc(sizeof(struct Node));
    head->next->id = 20;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->id = 30;
    head->next->next->next = malloc(sizeof(struct Node));
    head->next->next->next->id = 40;
    head->next->next->next->next = NULL;

    int target_id = 30;

    // Call deleteNodeByValue with &head and target_id
    // Your code here

    return 0;
}

Hint

Check if the head node itself has the target id. If yes, update head. Otherwise, traverse the list to find the node and remove it by changing the previous node's next pointer.

4

Print the linked list after deletion

Write a printList function that takes head and prints the id values of nodes separated by -> and ending with NULL. Call printList(head) in main after deleting the node.

DSA C

#include 
#include 

struct Node {
    int id;
    struct Node* next;
};

void deleteNodeByValue(struct Node** head_ref, int target_id) {
    struct Node* temp = *head_ref;
    struct Node* prev = NULL;

    if (temp != NULL && temp->id == target_id) {
        *head_ref = temp->next;
        free(temp);
        return;
    }

    while (temp != NULL && temp->id != target_id) {
        prev = temp;
        temp = temp->next;
    }

    if (temp == NULL) return;

    prev->next = temp->next;
    free(temp);
}

// Write printList function here

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->id = 10;
    head->next = malloc(sizeof(struct Node));
    head->next->id = 20;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->id = 30;
    head->next->next->next = malloc(sizeof(struct Node));
    head->next->next->next->id = 40;
    head->next->next->next->next = NULL;

    int target_id = 30;

    deleteNodeByValue(&head, target_id);

    // Call printList with head
    // Your code here

    return 0;
}

Hint

Traverse the list and print each node's id followed by ->. End with NULL and a newline.

Practice

1. What is the main purpose of the Delete Node by Value operation in a linked list?

easy

A. To remove the first node that contains the given value from the list

B. To add a new node with the given value at the end of the list

C. To find the position of a node with the given value

D. To reverse the linked list

Solution

1. Step 1: Understand the operation's goal

   The operation aims to remove a node that matches a specific value from the linked list.

2. Step 2: Identify the correct description

   Removing the first node with the given value matches To remove the first node that contains the given value from the list, while others describe different operations.

3. Final Answer:

   To remove the first node that contains the given value from the list -> Option A

4. Quick Check:

   Delete Node by Value = Remove matching node [OK]

Hint: Deleting by value means removing the first matching node [OK]

Common Mistakes:

• Confusing deletion by value with insertion
• Thinking it reverses the list
• Assuming it finds position only

2. Which of the following is the correct way to start deleting a node by value in a singly linked list in C?

easy

A. Reverse the list before deletion

B. Directly free the head pointer without checks

C. Create a new node with the value to delete

D. Set a pointer to the head and check if head's value matches

Solution

1. Step 1: Understand deletion start

   We must check if the head node itself contains the value to delete before moving forward.

2. Step 2: Identify correct approach

   Setting a pointer to head and checking its value is the correct first step; other options are incorrect or irrelevant.

3. Final Answer:

   Set a pointer to the head and check if head's value matches -> Option D

4. Quick Check:

   Start at head to delete by value [OK]

Hint: Always check head node first when deleting by value [OK]

Common Mistakes:

• Freeing head without checking value
• Creating new nodes unnecessarily
• Reversing list before deletion

3. Consider the following linked list: 10 -> 20 -> 30 -> 40 -> NULL. After deleting the node with value 30, what will be the new list?

medium

A. 10 -> 30 -> 40 -> NULL

B. 10 -> 20 -> 40 -> NULL

C. 20 -> 30 -> 40 -> NULL

D. 10 -> 20 -> 30 -> 40 -> NULL

Solution

1. Step 1: Locate node with value 30

   Traverse the list: 10, 20, then 30 is found as the third node.

2. Step 2: Remove node 30 and link previous to next

   Link node with value 20 directly to node with value 40, skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> NULL -> Option B

4. Quick Check:

   Deleted 30, list skips it [OK]

Hint: Link previous node to next to remove target node [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Deleting wrong node
• Leaving deleted node in list

4. Given this code snippet to delete a node by value, what is the main error?

void deleteNode(Node** head, int val) {
  Node* temp = *head;
  Node* prev = NULL;
  while (temp != NULL && temp->data != val) {
    prev = temp;
    temp = temp->next;
  }
  free(temp);
  if (prev != NULL) {
    prev->next = temp->next;
  } else {
    *head = temp->next;
  }
}

medium

A. prev pointer is never updated

B. The loop condition is incorrect and never runs

C. free(temp) is called before updating pointers, causing invalid access

D. The function does not handle empty list

Solution

1. Step 1: Analyze order of free and pointer update

   The code frees temp before updating prev->next or head, so temp->next access is invalid.

2. Step 2: Identify correct fix

   Pointers must be updated before freeing the node to avoid accessing freed memory.

3. Final Answer:

   free(temp) is called before updating pointers, causing invalid access -> Option C

4. Quick Check:

   Free after pointer update to avoid errors [OK]

Hint: Update pointers before freeing node to avoid invalid access [OK]

Common Mistakes:

• Freeing node before fixing links
• Ignoring NULL list case
• Not updating prev pointer

5. You have a singly linked list: 5 -> 10 -> 15 -> 20 -> 25 -> NULL. Write a function to delete all nodes with value greater than 15. What will be the final list after deletion?

hard

A. 5 -> 10 -> 15 -> NULL

B. 5 -> 10 -> 20 -> 25 -> NULL

C. 15 -> 20 -> 25 -> NULL

D. 5 -> 10 -> 15 -> 20 -> 25 -> NULL

Solution

1. Step 1: Identify nodes with value > 15

   Nodes with values 20 and 25 are greater than 15 and must be deleted.

2. Step 2: Delete nodes and link remaining nodes

   After removing 20 and 25, the list becomes 5 -> 10 -> 15 -> NULL.

3. Final Answer:

   5 -> 10 -> 15 -> NULL -> Option A

4. Quick Check:

   Removed nodes > 15, list ends at 15 [OK]

Hint: Delete nodes by checking value > 15 and relink list [OK]

Common Mistakes:

• Deleting wrong nodes
• Not updating links after deletion
• Assuming only one node deleted