Read Time:3 Minute, 42 Second

Deleting a node from a doubly linked list

Deleting a node from the beginning of the list

C Code
void deleteAtBegin() {
    if(head == NULL) {
        printf("List is empty, no deletion can be performed.");
        return;
    }
    struct node* temp = head;
    head = head->next;
    head->prev = NULL;
    free(temp);
}

Java Code
class Node {
    int data;
    Node prev;
    Node next;

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

class DoublyLinkedList {
    Node head;

    public void deleteAtStart() {
        if(head == null) {
            System.out.println("List is empty");
            return;
        }

        //update the head pointer to point to the next node
        head = head.next;
        head.prev = null;
    }
}

Python code

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

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

    def deleteAtStart(self):
        if self.head is None:
            print("List is empty")
            return
        
        #update the head pointer to point to the next node
        self.head = self.head.next
        self.head.prev = None

deleting a node from a specific position in a doubly linked list

Java Code:

class Node {
    int data;
    Node prev;
    Node next;
 
    // Constructor to create a new node
    Node(int d) {
        data = d;
        prev = null;
        next = null;
    }
}
 
class DoublyLinkedList {
    Node head;
 
    // Function to delete a node from specific position
    public void deleteNodeFromPosition(int position) {
        // If linked list is empty
        if (head == null) {
            return;
        }
        // If the position to delete is 0
        // i.e. delete the head node
        if (position == 0) {
            head = head.next;
            head.prev = null;
            return;
        }
        // Get the node at the position to delete
        Node current = head;
        int count = 0;
        while (count < position && current != null) {
            current = current.next;
            count++;
        }
        // If the position is greater than the size of the list
        if (current == null || current.next == null) {
            return;
        }
        // Unlink the node from the list
        current.prev.next = current.next;
        current.next.prev = current.prev;
    }
}

Python code:

class Node:
    def __init__(self, data=None, prev=None, next=None):
        self.data = data
        self.prev = prev
        self.next = next
 
class DoublyLinkedList:
    def __init__(self):
        self.head = None
 
    def delete_node_from_position(self, position):
        # If linked list is empty
        if self.head is None:
            return
        # If the position to delete is 0
        # i.e. delete the head node
        if position == 0:
            self.head = self.head.next
            self.head.prev = None
            return
        # Get the node at the position to delete
        current = self.head
        count = 0
        while count < position and current is not None:
            current = current.next
            count += 1
        # If the position is greater than the size of the list
        if current is None or current.next is None:
            return
        # Unlink the node from the list
        current.prev.next = current.next
        current.next.prev = current.prev

Implementation of deleting a node with specific value in a doubly linked list in Java:

class Node {
    int data;
    Node next, prev;
};

class DoublyLinkedList {
    Node head;
    int size;

    public DoublyLinkedList() {
        head = null;
        size = 0;
    }

    public void add(int data) {
        Node node = new Node();
        node.data = data;
        node.next = head;
        node.prev = null;
        if (head != null) {
            head.prev = node;
        }
        head = node;
        size++;
    }

    public void deleteValue(int value) {
        Node node = head;
        while (node != null && node.data != value) {
            node = node.next;
        }
        if (node == null) {
            System.out.println("Value not found");
        } else {
            if (node.prev != null) {
                node.prev.next = node.next;
            } else {
                head = node.next;
            }
            if (node.next != null) {
                node.next.prev = node.prev;
            }
            size--;
        }
    }
}

Implementation of the same in Python

Table of Contents

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

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

    def add(self, data):
        node = Node(data)
        node.next = self.head
        node.prev = None
        if self.head is not None:
            self.head.prev = node
        self.head = node
        self.size += 1

    def deleteValue(self, value):
        node = self.head
        while node is not None and node.data != value:
            node = node.next
        if node is None:
            print("Value not found")
        else:
            if node.prev is not None:
                node.prev.next = node.next
            else:
                self.head = node.next
            if node.next is not None:
                node.next.prev = node.prev
            self.size -= 1

In both codes, the deleteValue method starts at the head of the linked list and searches for the first node with the specified value. If the value is found, the links of the surrounding nodes are updated to exclude the node with the specified value. If the node with the specified value is not found, an error message is printed.