Delete Node by Value in DSA C

Mental Model

To remove a node with a specific value, find it first, then change the links to skip it.

Analogy: Imagine a chain of paper clips linked together. To remove one clip, you unhook it and connect the clips before and after it directly.

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

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4, delete value 3

Goal: Remove the node containing value 3 and keep the list connected

Step 1: start at head node with value 1

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

Why: We begin searching from the first node

Step 2: move curr to next node with value 2

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

Why: Value 1 is not 3, so continue searching

Step 3: move curr to next node with value 3

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

Why: Found node with value 3 to delete

Step 4: change next pointer of node with value 2 to node with value 4, skipping 3

head -> 1 -> 2 -> 4 -> null

Why: By skipping node 3, it is removed from the list

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA C

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

// Define node structure
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Create new node
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Insert node at end
void insertEnd(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    Node* curr = *head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
}

// Delete node by value
void deleteNodeByValue(Node** head, int value) {
    if (*head == NULL) return; // empty list

    // If head node holds the value
    if ((*head)->data == value) {
        Node* temp = *head;
        *head = (*head)->next; // move head
        free(temp);
        return;
    }

    Node* curr = *head;
    // Traverse to find node before the one to delete
    while (curr->next != NULL && curr->next->data != value) {
        curr = curr->next; // advance curr
    }

    // If node with value found
    if (curr->next != NULL) {
        Node* temp = curr->next;
        curr->next = curr->next->next; // skip node
        free(temp);
    }
}

// Print list
void printList(Node* head) {
    Node* curr = head;
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("null\n");
}

int main() {
    Node* head = NULL;
    insertEnd(&head, 1);
    insertEnd(&head, 2);
    insertEnd(&head, 3);
    insertEnd(&head, 4);

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

    deleteNodeByValue(&head, 3);

    printf("List after deleting value 3:\n");
    printList(head);

    return 0;
}

if ((*head)->data == value) {

check if head node contains the value to delete

*head = (*head)->next; // move head

remove head by moving head pointer to next node

while (curr->next != NULL && curr->next->data != value) {

traverse list to find node before the one to delete

curr->next = curr->next->next; // skip node

unlink node with value by skipping it in the chain

Output

Original list:

1 -> 2 -> 3 -> 4 -> null

List after deleting value 3:

1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we may need to check each node once to find the value

Space: O(1) because we only use a few pointers and no extra data structures

vs Alternative: Compared to rebuilding the list without the value, this method is faster because it changes links directly without copying nodes

Edge Cases

empty list

function returns immediately without changes

DSA C

if (*head == NULL) return; // empty list

value is at head node

head pointer moves to next node, old head freed

DSA C

if ((*head)->data == value) {

value not found in list

list remains unchanged

DSA C

if (curr->next != NULL) {

When to Use This Pattern

When you need to remove a specific value from a linked list, use the delete-by-value pattern to find and unlink the node efficiently.

Common Mistakes

Mistake: Not handling deletion of the head node separately
Fix: Add a check for head node value before traversing the list

Mistake: Not updating the previous node's next pointer to skip the deleted node
Fix: Set previous node's next to deleted node's next to unlink it

Summary

Deletes the first node with a given value from a linked list.

Use when you want to remove a node by its value, not by position.

Remember to handle the head node separately and update links to skip the deleted node.