How to Delete a Node from Linked List in C++

To delete a node from a linked list in C++, locate the node, adjust the previous node's next pointer to skip the node to delete, then free the node's memory using delete. Handle special cases like deleting the head node carefully to avoid memory leaks or dangling pointers.

Syntax

Here is the basic syntax to delete a node from a singly linked list in C++:

• Node* temp = head; — Start from the head node.
• while (temp->next != nullptr && temp->next->data != value) temp = temp->next; — Find the node before the one to delete.
• Node* toDelete = temp->next; — Node to remove.
• temp->next = toDelete->next; — Bypass the node to delete.
• delete toDelete; — Free memory.

For deleting the head node, update head pointer directly.

cpp

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

void deleteNode(Node*& head, int value) {
    if (head == nullptr) return;

    if (head->data == value) {
        Node* toDelete = head;
        head = head->next;
        delete toDelete;
        return;
    }

    Node* temp = head;
    while (temp->next != nullptr && temp->next->data != value) {
        temp = temp->next;
    }

    if (temp->next == nullptr) return; // value not found

    Node* toDelete = temp->next;
    temp->next = toDelete->next;
    delete toDelete;
}

Example

This example creates a linked list, deletes a node with a specific value, and prints the list before and after deletion.

cpp

#include <iostream>

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

void printList(Node* head) {
    while (head != nullptr) {
        std::cout << head->data << " ";
        head = head->next;
    }
    std::cout << std::endl;
}

void deleteNode(Node*& head, int value) {
    if (head == nullptr) return;

    if (head->data == value) {
        Node* toDelete = head;
        head = head->next;
        delete toDelete;
        return;
    }

    Node* temp = head;
    while (temp->next != nullptr && temp->next->data != value) {
        temp = temp->next;
    }

    if (temp->next == nullptr) return; // value not found

    Node* toDelete = temp->next;
    temp->next = toDelete->next;
    delete toDelete;
}

int main() {
    Node* head = new Node{1, nullptr};
    head->next = new Node{2, nullptr};
    head->next->next = new Node{3, nullptr};
    head->next->next->next = new Node{4, nullptr};

    std::cout << "Original list: ";
    printList(head);

    deleteNode(head, 3);

    std::cout << "After deleting 3: ";
    printList(head);

    // Clean up remaining nodes
    while (head != nullptr) {
        Node* temp = head;
        head = head->next;
        delete temp;
    }

    return 0;
}

Output

Original list: 1 2 3 4 
After deleting 3: 1 2 4 

Common Pitfalls

Common mistakes when deleting a node from a linked list include:

• Not handling deletion of the head node separately, which can cause the list head to become invalid.
• Forgetting to update the previous node's next pointer, leaving the list broken.
• Not freeing the memory of the deleted node, causing memory leaks.
• Trying to delete a node that does not exist, which should be safely ignored.

cpp

/* Wrong way: Not handling head deletion */
void wrongDelete(Node* head, int value) {
    Node* temp = head;
    while (temp->next != nullptr && temp->next->data != value) {
        temp = temp->next;
    }
    if (temp->next == nullptr) return;
    Node* toDelete = temp->next;
    temp->next = toDelete->next;
    delete toDelete;
}

/* Right way: Pass head by reference and handle head deletion */
void rightDelete(Node*& head, int value) {
    if (head == nullptr) return;
    if (head->data == value) {
        Node* toDelete = head;
        head = head->next;
        delete toDelete;
        return;
    }
    Node* temp = head;
    while (temp->next != nullptr && temp->next->data != value) {
        temp = temp->next;
    }
    if (temp->next == nullptr) return;
    Node* toDelete = temp->next;
    temp->next = toDelete->next;
    delete toDelete;
}

Quick Reference

• Always check if the list is empty before deleting.
• Handle the head node deletion separately.
• Update pointers carefully to maintain list integrity.
• Free memory of deleted nodes to avoid leaks.
• Ignore deletion if the node with the given value is not found.

Key Takeaways

Always handle deletion of the head node separately by updating the head pointer.

Update the previous node's next pointer to skip the node being deleted.

Use delete to free memory of the removed node to prevent memory leaks.

Check if the node to delete exists before attempting deletion.

Pass the head pointer by reference if you may modify it during deletion.