Delete a Doubly Linked List node at a given position

Given the head of a doubly linked list and an integer x, delete the node at the x-th position (1-based index) from the beginning of the list.

• If x = 1, delete the head node and update the head pointer.
• If x is greater than the length of the list, no deletion should be performed.

Ensure that the list remains valid after deletion, i.e., the prev and next pointers of the remaining nodes are correctly updated.

Input: x = 2

Output: 1 <-> 3
Explanation: The node at position 2 is 2. After deleting it, the remaining list is 1 <-> 3.

[Approach] Traversal and Pointer Adjustment - O(n) Time and O(1) Space

The idea is simple: find the node at the given position and remove it by updating the links of the nodes before and after it, so the list stays connected. If the node to delete is the head, we just move the head to the next node.

Step by Step Approach:

• If the list is empty, there’s nothing to delete, so just return the head.
• Go through the list to find the x-th node. If x is larger than the number of nodes, just return the head as it is.
• If x is 1, we need to remove the head: move the head to the next node and make sure its previous link is null, then delete the old head.
• For any other node, link its previous node to its next node, and if there’s a next node, link it back to the previous node, then remove the current node.
• Return the head of the updated list.

Handling Deletion of Head and Last Node

Head Node: If the node to remove is the first one, we must move the head pointer to the next node. At the same time, if a next node exists, we should make sure its backward link no longer points to the old head.

Last Node: If the node to remove is the last one, we cut the link from its previous node so that the previous node becomes the new end of the list. In this case, the forward link is set to null.

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* prev;
    Node* next;
    Node(int d) {
        data = d;
        prev = next = NULL;
    }
};

Node* delPos(Node* head, int x) {
    
    if (head == NULL)
        return head; 

    Node* curr = head;

    // traverse to the node at the given position
    for (int i = 1; curr != NULL && i < x; ++i) {
        curr = curr->next;
    }
    
    // position exceeds list length, no deletion
    if (curr == NULL)
        return head; 

    // if the node to delete is not the first node
    // update previous node's next
    if (curr->prev != NULL)
        curr->prev->next = curr->next;

    // if the node to delete is not the last node
    // update next node's prev
    if (curr->next != NULL)
        curr->next->prev = curr->prev;

    // if deleting the head, move head pointer to next node
    if (head == curr)
        head = curr->next;
        
    delete curr; 
    return head;
}

// function to print the doubly linked list
void printList(Node* head) {
    Node* curr = head;
    while (curr != nullptr) {
        cout << curr->data;
        if (curr->next != nullptr) {
            cout << " <-> ";
        }
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->prev = head;
    head->next->next = new Node(3);
    head->next->next->prev = head->next;

    head = delPos(head, 2);

    printList(head);

    return 0;
}

class Node {
    int data;
    Node prev;
    Node next;
    Node(int d) {
        data = d;
        prev = next = null;
    }
}

class GfG {

    public static Node delPos(Node head, int x) {
        
        if (head == null){
            return head; 
        }

        Node curr = head;

        // traverse to the node at the given position
        for (int i = 1; curr != null && i < x; i++) {
            curr = curr.next;
        }

        if (curr == null){
            // position exceeds list length, no deletion
            return head; 
        }

        // if the node to delete is not the first node
        // update previous node's next
        if (curr.prev != null)
            curr.prev.next = curr.next;

        // if the node to delete is not the last node
        // update next node's prev
        if (curr.next != null)
            curr.next.prev = curr.prev;

        // if deleting the head, move head pointer to next node
        if (head == curr)
            head = curr.next;
        
        curr = null; 
        return head;
    }
    
    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) {
                System.out.print(" <-> ");
            }
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.prev = head;
        head.next.next = new Node(3);
        head.next.next.prev = head.next;

        head = delPos(head, 2);

        printList(head);
    }
}

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

def delPos(head, x):
    
    if head is None:
        return head  

    curr = head

    # traverse to the node at the given position
    for i in range(1, x):
        if curr is None:
            # position exceeds list length, no deletion
            return head  
        curr = curr.next

    if curr is None:
        # position exceeds list length, no deletion
        return head  

    # if the node to delete is not the first node
    # update previous node's next
    if curr.prev is not None:
        curr.prev.next = curr.next

    # if the node to delete is not the last node
    # update next node's prev
    if curr.next is not None:
        curr.next.prev = curr.prev

    # if deleting the head, move head pointer 
    # to next node
    if head == curr:
        head = curr.next

    del curr  # free memory of the deleted node
    return head

def printList(head):
    curr = head
    while curr is not None:
        print(curr.data, end='')
        if curr.next is not None:
            print(' <-> ', end='')
        curr = curr.next
    print()

if __name__ == "__main__":
    head = Node(1)
    head.next = Node(2)
    head.next.prev = head
    head.next.next = Node(3)
    head.next.next.prev = head.next

    head = delPos(head, 2)

    printList(head)

using System;

class Node {
    public int data;
    public Node prev;
    public Node next;
    public Node(int d) { 
        data = d; prev = next = null; 
    }
}

class GfG {

    static Node delPos(Node head, int x) {
        
        if (head == null)
            return head;

        Node curr = head;

        // traverse to the node at the given position
        for (int i = 1; curr != null && i < x; i++) {
            curr = curr.next;
        }
        
        // position exceeds list length, no deletion
        if (curr == null) return head; 

        // if the node to delete is not the first node
        // update previous node's next
        if (curr.prev != null) curr.prev.next = curr.next;

        // if the node to delete is not the last node
        // update next node's prev
        if (curr.next != null) curr.next.prev = curr.prev;

        // if deleting the head, move head pointer
        // to next node
        if (head == curr) head = curr.next;
    
        curr = null; 
        return head;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data);
            if (curr.next != null)
                Console.Write(" <-> ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    public static void Main(string[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.prev = head;
        head.next.next = new Node(3);
        head.next.next.prev = head.next;
        
        head = delPos(head, 2);

        printList(head);
    }
}

class Node {
    constructor(data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

function delPos(head, x) {
    
    if (head === null)
        return head; 

    let curr = head;

    // traverse to the node at the given position
    for (let i = 1; curr !== null && i < x; i++) {
        curr = curr.next;
    }
    
    // position exceeds list length, no deletion
    if (curr === null) return head; 

    // if the node to delete is not the first node
    // update previous node's next
    if (curr.prev !== null) curr.prev.next = curr.next;

    // if the node to delete is not the last node
    // update next node's prev
    if (curr.next !== null) curr.next.prev = curr.prev;

    // if deleting the head, move head pointer to next node
    if (head === curr) head = curr.next;

    curr = null; 
    return head;
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        process.stdout.write(curr.data.toString());
        if (curr.next !== null)
            process.stdout.write(" <-> ");
        curr = curr.next;
    }
    console.log();
}

// Driver Code
let head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;

head = delPos(head, 2);

printList(head);

1 <-> 3