Deleting a Node in a Linked List

Introduction

Linked lists are fundamental data structures in computer science, important for dynamic memory allocation and power insertion and removal capabilities. Deleting a node from a linked list may seem straightforward, but there are important techniques and considerations to ensure correct functionality and scalability. This guide provides a comprehensive overview of linked list deletion, covering different scenarios and types of linked lists and providing remote codes and code examples.

Basic information about deleting a linked list

In a singly linked list, each node points to another node. Deleting a node requires updating the prior node's pointers to reflect the subsequent node's pointers, except the deleting node. This effectively removes the node from the linked list.

Removal of Head node: If the target node is the head node (the first node), the master indicator must be updated on the second node, thereby removing the original primary node.

Removal of the middle node: Removal of the node from the middle requires the pointers of the previous node to be shown on the node after the new removal node, thereby skipping the removal node.

Removal of an end node: To remove an end node (the last node), the pointers of the second to last node must be updated to the new removal node, thereby removing the original end node.

Pseudo code for Linked List Deletion

function deleteNode(list, target):
    if list is empty:
        return

    if list.head.value == target:
        list.head = list.head.next
        return

    current = list.head
    while current.next is not null:
        if current.next.value == target:
            current.next = current.next.next
            return
        current = current.next

Using Various Linked List Types for Deletion

Singly Linked List: Deletion involves adjusting pointers of the previous node to bypass the target node. Time complexity: O(n).

Doubly Linked List: Deletion requires updating pointers of both previous and next nodes. Time complexity: O(n). Allows bidirectional traversal for efficient node location.

Circular Linked List: Deletion is similar to a singly linked list with special consideration for head and tail nodes.

Point to Remember

Null Pointer Check: Always check for null pointers before attempting any deletions to avoid runtime errors.

Memory Management: Remember to free the memory occupied by the deleted node to prevent memory leaks.

Special Case Handling: Pay special attention to edge cases, such as deleting the head or tail node, to maintain the linked list's integrity.

Update References: After deleting a node, properly update the references or pointers of surrounding nodes to maintain the linked list's connectivity.

Complexity Analysis: Remember that deletion in linked lists generally has a time complexity of O(n), where n is the number of nodes in the list.

Example on how to delete a node in a singly linked list

Start from the head node and traverse the list while keeping track of the current position.
When you reach the desired position (position - 1), update the pointer of the previous node to point to the node after the one you want to delete.
Get rid of the node you're deleting to free up memory.

Python Code

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    # Add a new node to the end of the linked list
    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    # Display the linked list
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

    # Delete a node at a given position
    def delete_node_at_position(self, position):
        if not self.head:
            print("List is empty. Nothing to delete.")
            return

        if position == 0:
            self.head = self.head.next
            return

        current = self.head
        prev = None
        current_position = 0

        while current is not None and current_position < position:
            prev = current
            current = current.next
            current_position += 1

        if current is None:
            print("Position is out of bounds.")
            return

        prev.next = current.next

# Example usage
linked_list = LinkedList()
linked_list.append(5)
linked_list.append(6)
linked_list.append(7)
linked_list.append(8)

print("Original linked list:")
linked_list.display()

position = 2
linked_list.delete_node_at_position(position)
print(f"Linked list after deleting node at position {position}:")
linked_list.display()

Output:

Java Code

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    Node head;

    // Add a new node to the end of the linked list
    void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
    }

    // Display the linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }

    // Delete a node at a given position
    void deleteNodeAtPosition(int position) {
        if (head == null) {
            System.out.println("List is empty. Nothing to delete.");
            return;
        }

        if (position == 0) {
            head = head.next;
            return;
        }

        Node current = head;
        Node prev = null;
        int currentPosition = 0;

        while (current != null && currentPosition < position) {
            prev = current;
            current = current.next;
            currentPosition++;
        }

        if (current == null) {
            System.out.println("Position is out of bounds.");
            return;
        }

        prev.next = current.next;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.append(5);
        linkedList.append(6);
        linkedList.append(7);
        linkedList.append(8);

        System.out.println("Original linked list:");
        linkedList.display();

        int position = 2;
        linkedList.deleteNodeAtPosition(position);
        System.out.println("Linked list after deleting node at position " + position + ":");
        linkedList.display();
    }
}

Output:

C++ Code

#include <iostream>

class Node {
public:
    int data;
    Node* next;

    Node(int data) {
        this->data = data;
        this->next = nullptr;
    }
};

class LinkedList {
public:
    Node* head;

    LinkedList() {
        head = nullptr;
    }

    // Add a new node to the end of the linked list
    void append(int data) {
        Node* newNode = new Node(data);
        if (head == nullptr) {
            head = newNode;
            return;
        }
        Node* current = head;
        while (current->next != nullptr) {
            current = current->next;
        }
        current->next = newNode;
    }

    // Display the linked list
    void display() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " -> ";
            current = current->next;
        }
        std::cout << "nullptr" << std::endl;
    }

    // Delete a node at a given position
    void deleteNodeAtPosition(int position) {
        if (head == nullptr) {
            std::cout << "List is empty. Nothing to delete." << std::endl;
            return;
        }

        if (position == 0) {
            head = head->next;
            return;
        }

        Node* current = head;
        Node* prev = nullptr;
        int currentPosition = 0;

        while (current != nullptr && currentPosition < position) {
            prev = current;
            current = current->next;
            currentPosition++;
        }

        if (current == nullptr) {
            std::cout << "Position is out of bounds." << std::endl;
            return;
        }

        prev->next = current->next;
        delete current;
    }
};

int main() {
    LinkedList linkedList;
    linkedList.append(5);
    linkedList.append(6);
    linkedList.append(7);
    linkedList.append(8);

    std::cout << "Original linked list:" << std::endl;
    linkedList.display();

    int position = 2;
    linkedList.deleteNodeAtPosition(position);
    std::cout << "Linked list after deleting node at position " << position << ":" << std::endl;
    linkedList.display();

    return 0;
}

Output:

Deleting a Node at the Beginning in a Doubly Linked List

Pseudo code for deleting a node at the beginning of a doubly linked list

function deleteNodeAtBeginning(doublyLinkedList):
    if doublyLinkedList is empty:
        return

    if doublyLinkedList.head == null:
        return

    if doublyLinkedList.head == doublyLinkedList.tail:
        doublyLinkedList.head = null
        doublyLinkedList.tail = null
        return

    newHead = doublyLinkedList.head.next
    newHead.previous = null
    doublyLinkedList.head = newHead

If the list is empty, there's nothing to delete.
If the list has only one node, set the head and tail pointers to null.
Otherwise, update the head pointer to point to the next node.
Set the new head's previous pointer to null to sever the connection to the deleted node.

Java Code

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.previous = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            self.tail = new_node
        else:
            new_node.previous = self.tail
            self.tail.next = new_node
            self.tail = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" <-> ")
            current = current.next
        print("None")

    def delete_node_at_beginning(self):
        if not self.head:
            print("List is empty. Nothing to delete.")
            return

        if self.head == self.tail:
            self.head = None
            self.tail = None
            return

        new_head = self.head.next
        new_head.previous = None
        self.head = new_head

# Example usage
doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(5)
doubly_linked_list.append(6)
doubly_linked_list.append(7)
doubly_linked_list.append(8)

print("Original doubly linked list:")
doubly_linked_list.display()

doubly_linked_list.delete_node_at_beginning()
print("Doubly linked list after deleting node at the beginning:")
doubly_linked_list.display()

Output:

Java Code

class Node {
    int data;
    Node next;
    Node previous;

    Node(int data) {
        this.data = data;
        this.next = null;
        this.previous = null;
    }
}

class DoublyLinkedList {
    Node head;
    Node tail;

    // Add a new node to the end of the doubly linked list
    void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.previous = tail;
            tail.next = newNode;
            tail = newNode;
        }
    }

    // Display the doubly linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }

    // Delete a node at the beginning of the doubly linked list
    void deleteNodeAtBeginning() {
        if (head == null) {
            System.out.println("List is empty. Nothing to delete.");
            return;
        }

        if (head == tail) {
            head = null;
            tail = null;
            return;
        }

        Node newHead = head.next;
        newHead.previous = null;
        head = newHead;
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList doublyLinkedList = new DoublyLinkedList();
        doublyLinkedList.append(5);
        doublyLinkedList.append(6);
        doublyLinkedList.append(7);
        doublyLinkedList.append(8);

        System.out.println("Original doubly linked list:");
        doublyLinkedList.display();

        doublyLinkedList.deleteNodeAtBeginning();
        System.out.println("Doubly linked list after deleting node at the beginning:");
        doublyLinkedList.display();
    }
}

Output:

C++ Code

#include <iostream>

class Node {
public:
    int data;
    Node* next;
    Node* previous;

    Node(int data) {
        this->data = data;
        this->next = nullptr;
        this->previous = nullptr;
    }
};

class DoublyLinkedList {
public:
    Node* head;
    Node* tail;

    DoublyLinkedList() {
        head = nullptr;
        tail = nullptr;
    }

    // Add a new node to the end of the doubly linked list
    void append(int data) {
        Node* newNode = new Node(data);
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            newNode->previous = tail;
            tail->next = newNode;
            tail = newNode;
        }
    }

    // Display the doubly linked list
    void display() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " <-> ";
            current = current->next;
        }
        std::cout << "null" << std::endl;
    }

    // Delete a node at the beginning of the doubly linked list
    void deleteNodeAtBeginning() {
        if (head == nullptr) {
            std::cout << "List is empty. Nothing to delete." << std::endl;
            return;
        }

        if (head == tail) {
            head = nullptr;
            tail = nullptr;
            return;
        }

        Node* newHead = head->next;
        newHead->previous = nullptr;
        head = newHead;
    }
};

int main() {
    DoublyLinkedList doublyLinkedList;
    doublyLinkedList.append(5);
    doublyLinkedList.append(6);
    doublyLinkedList.append(7);
    doublyLinkedList.append(8);

    std::cout << "Original doubly linked list:" << std::endl;
    doublyLinkedList.display();

    doublyLinkedList.deleteNodeAtBeginning();
    std::cout << "Doubly linked list after deleting node at the beginning:" << std::endl;
    doublyLinkedList.display();

    return 0;
}

Output:

Delete a Node at a Middle in Doubly Linked List

Pseudo code for Doubly Linked List Deletion

function deleteNodeAtMiddle(doublyLinkedList, targetNode):
    if doublyLinkedList is empty:
        return

    current = doublyLinkedList.head
    while current is not null:
        if current == targetNode:
            prev_node = current.previous
            next_node = current.next
            prev_node.next = next_node
            next_node.previous = prev_node
            return
        current = current.next

Traverse the list to locate the node you want to delete.
Update the previous node's next pointer to point to the node after the one you want to delete.
Update the next node's previous pointer to point to the node before the one you want to delete.
Get rid of the node you're deleting to free up memory.

Python Code

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.previous = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            self.tail = new_node
        else:
            new_node.previous = self.tail
            self.tail.next = new_node
            self.tail = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" <-> ")
            current = current.next
        print("None")

    def delete_node_at_middle(self, target_data):
        if not self.head:
            print("List is empty. Nothing to delete.")
            return

        current = self.head
        while current:
            if current.data == target_data:
                prev_node = current.previous
                next_node = current.next
                prev_node.next = next_node
                next_node.previous = prev_node
                return
            current = current.next

        print(f"Node with data {target_data} not found in the list.")

# Example usage
doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(5)
doubly_linked_list.append(6)
doubly_linked_list.append(7)
doubly_linked_list.append(8)

print("Original doubly linked list:")
doubly_linked_list.display()

target_data = 6
doubly_linked_list.delete_node_at_middle(target_data)
print(f"Doubly linked list after deleting node with data {target_data} from the middle:")
doubly_linked_list.display()

Output:

Java Code

class Node {
    int data;
    Node next;
    Node previous;

    Node(int data) {
        this.data = data;
        this.next = null;
        this.previous = null;
    }
}

class DoublyLinkedList {
    Node head;
    Node tail;

    // Add a new node to the end of the doubly linked list
    void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.previous = tail;
            tail.next = newNode;
            tail = newNode;
        }
    }

    // Display the doubly linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }

    // Delete a node at the middle of the doubly linked list
    void deleteNodeAtMiddle(int targetData) {
        if (head == null) {
            System.out.println("List is empty. Nothing to delete.");
            return;
        }

        Node current = head;
        while (current != null) {
            if (current.data == targetData) {
                Node prevNode = current.previous;
                Node nextNode = current.next;

                if (prevNode != null) {
                    prevNode.next = nextNode;
                } else {
                    head = nextNode; // Update the head if the first node is the target
                }

                if (nextNode != null) {
                    nextNode.previous = prevNode;
                } else {
                    tail = prevNode; // Update the tail if the last node is the target
                }

                return;
            }
            current = current.next;
        }

        System.out.println("Node with data " + targetData + " not found in the list.");
    }
}

public class DoublyLinkedListMain {
    public static void main(String[] args) {
        DoublyLinkedList doublyLinkedList = new DoublyLinkedList();
        doublyLinkedList.append(5);
        doublyLinkedList.append(6);
        doublyLinkedList.append(7);
        doublyLinkedList.append(8);

        System.out.println("Original doubly linked list:");
        doublyLinkedList.display();

        int targetData = 6;
        doublyLinkedList.deleteNodeAtMiddle(targetData);
        System.out.println("Doubly linked list after deleting node with data " + targetData + " from the middle:");
        doublyLinkedList.display();
    }
}

Output:

C++ Code

// Online C++ compiler to run C++ program online
#include <iostream>

class Node {
public:
    int data;
    Node* next;
    Node* previous;

    Node(int data) {
        this->data = data;
        this->next = nullptr;
        this->previous = nullptr;
    }
};

class DoublyLinkedList {
public:
    Node* head;
    Node* tail;

    DoublyLinkedList() {
        head = nullptr;
        tail = nullptr;
    }

    // Add a new node to the end of the doubly linked list
    void append(int data) {
        Node* newNode = new Node(data);
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            newNode->previous = tail;
            tail->next = newNode;
            tail = newNode;
        }
    }

    // Display the doubly linked list
    void display() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " <-> ";
            current = current->next;
        }
        std::cout << "null" << std::endl;
    }

    // Delete a node at the middle of the doubly linked list
    void deleteNodeAtMiddle(int targetData) {
        if (head == nullptr) {
            std::cout << "List is empty. Nothing to delete." << std::endl;
            return;
        }

        Node* current = head;
        while (current != nullptr) {
            if (current->data == targetData) {
                Node* prevNode = current->previous;
                Node* nextNode = current->next;

                if (prevNode != nullptr) {
                    prevNode->next = nextNode;
                } else {
                    head = nextNode; // Update the head if the first node is the target
                }

                if (nextNode != nullptr) {
                    nextNode->previous = prevNode;
                } else {
                    tail = prevNode; // Update the tail if the last node is the target
                }

                delete current; // Free the memory of the deleted node
                return;
            }
            current = current->next;
        }

        std::cout << "Node with data " << targetData << " not found in the list." << std::endl;
    }
};

int main() {
    DoublyLinkedList doublyLinkedList;
    doublyLinkedList.append(5);
    doublyLinkedList.append(6);
    doublyLinkedList.append(7);
    doublyLinkedList.append(8);

    std::cout << "Original doubly linked list:" << std::endl;
    doublyLinkedList.display();

    int targetData = 6;
    doublyLinkedList.deleteNodeAtMiddle(targetData);
    std::cout << "Doubly linked list after deleting node with data " << targetData << " from the middle:" << std::endl;
    doublyLinkedList.display();

    return 0;
}

Output:

Note:- While the initial method offers a robust solution, it's important to remember that other optimization strategies can be employed depending on the specific needs of your application. For instance, searching from both ends of the list can improve performance when the target node is expected closer to one end.

Conclusion

The code examples provided for Deleting a Node in a Linked List and examines complexity aspects. By understanding these concepts, you can better manage linked list deletion and understand their importance in different scenarios and types of linked lists.

Next TopicDiameter of a Binary Tree

← prev next →