Open In App

Delete a Doubly Linked List node at a given position

Last Updated : 31 Aug, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a doubly linked list and a position pos, the task is to delete the node at the given position from the beginning of Doubly Linked List.

Input: LinkedList: 1<->2<->3, pos = 2
Output: LinkedList: 1<->3

Input: LinkedList: 1<->2<->3, pos = 1
Output: LinkedList: 2<->3

Deletion-at-a-Specific-Position-in-Doubly-Linked-List
Delete Node at position 2 in Doubly Linked List

To delete a node at a specific position in doubly linked list, we can use the following steps:

  • Traverse to the node at the specified position, say curr.
  • If the position is valid, adjust the pointers to skip the node to be deleted.
    • If curr is not the head of the linked list, update the next pointer of the node before curr to point to the node after curr, curr->prev->next = curr-next.
    • If curr is not the last node of the linked list, update the previous pointer of the node after curr to the node before curr, curr->next->prev = curr->prev.
  • Free the memory allocated for the deleted node.
C++ 
// C++ Program to delete node at a specific position
// in Doubly Linked List

#include <iostream>
using namespace std;

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

// Function to delete a node at a specific position 
// in the doubly linked list
Node * delPos(Node* head, int pos) {

    // If the list is empty
    if (head == NULL)
        return head;

    Node * curr = head;

    // Traverse to the node at the given position
    for (int i = 1; curr != NULL && i < pos; ++i) {
        curr = curr -> next;
    }

    // If the position is out of range
    if (curr == NULL)
        return head;

    // Update the previous node's next pointer
    if (curr -> prev != NULL)
        curr -> prev -> next = curr -> next;

    // Update the next node's prev pointer
    if (curr -> next != NULL)
        curr -> next -> prev = curr -> prev;

    // If the node to be deleted is the head node
    if (head == curr)
        head = curr -> next;

    // Deallocate memory for the deleted node
    delete curr;
    return head;
}

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

int main() {

    // Create a hardcoded doubly linked list:
    // 1 <-> 2 <-> 3
    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;
}
C 
// C Program to delete node at a specific position
// in Doubly Linked List

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

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

// Function to delete a node at a specific position 
// in the doubly linked list
struct Node* delPos(struct Node* head, int pos) {

    // If the list is empty
    if (head == NULL)
        return head;

    struct Node* curr = head;

    // Traverse to the node at the given position
    for (int i = 1; curr != NULL && i < pos; ++i) {
        curr = curr->next;
    }

    // If the position is out of range
    if (curr == NULL)
        return head;

    // Update the previous node's next pointer
    if (curr->prev != NULL)
        curr->prev->next = curr->next;

    // Update the next node's prev pointer
    if (curr->next != NULL)
        curr->next->prev = curr->prev;

    // If the node to be deleted is the head node
    if (head == curr)
        head = curr->next;

    // Deallocate memory for the deleted node
    free(curr);
    return head;
}

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

struct Node* createNode(int d) {
    struct Node* new_node = 
    (struct Node*)malloc(sizeof(struct Node));
    new_node->data = d;
    new_node->prev = NULL;
    new_node->next = NULL;
    return new_node;
}

int main() {

    // Create a hardcoded doubly linked list:
    // 1 <-> 2 <-> 3
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->prev = head;
    head->next->next = createNode(3);
    head->next->next->prev = head->next;

    head = delPos(head, 2);

    printList(head);

    return 0;
}
Java 
// Java Program to delete node at a specific position
// in Doubly Linked List

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

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

public class GfG {

    // Function to delete a node at a specific position 
    // in the doubly linked list
    static Node delPos(Node head, int pos) {

        // If the list is empty
        if (head == null)
            return head;

        Node curr = head;

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

        // If the position is out of range
        if (curr == null)
            return head;

        // Update the previous node's next pointer
        if (curr.prev != null)
            curr.prev.next = curr.next;

        // Update the next node's prev pointer
        if (curr.next != null)
            curr.next.prev = curr.prev;

        // If the node to be deleted is the head node
        if (head == curr)
            head = curr.next;

        // Deallocate memory for the deleted node
        curr = null;
        return head;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {

        // Create a hardcoded doubly linked list:
        // 1 <-> 2 <-> 3
        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);
    }
}
Python 
# Python Program to delete node at a specific position
# in Doubly Linked List

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

# Function to delete a node at a specific position 
# in the doubly linked list
def del_pos(head, pos):

    # If the list is empty
    if head is None:
        return head

    curr = head

    for i in range(1, pos):
        if curr is None:
            break
        curr = curr.next

    if curr is None:
        return head

    # Update the previous node's next pointer
    if curr.prev is not None:
        curr.prev.next = curr.next

    # Update the next node's prev pointer
    if curr.next is not None:
        curr.next.prev = curr.prev

    # If the node to be deleted is the head node
    if head == curr:
        head = curr.next

    # Deallocate memory for the deleted node
    del curr
    return head

def print_list(head):
    curr = head
    while curr is not None:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":

    # Create a hardcoded doubly linked list:
    # 1 <-> 2 <-> 3
    head = Node(1)
    head.next = Node(2)
    head.next.prev = head
    head.next.next = Node(3)
    head.next.next.prev = head.next

    head = del_pos(head, 2)

    print_list(head)
C# 
// C# Program to delete node at a specific position
// in Doubly Linked List

using System;

class Node {
    public int Data;
    public Node prev;
    public Node next;

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

// Function to delete a node at a specific position 
// in the doubly linked list
class GfG {
    static Node DelPos(Node head, int pos) {

        // If the list is empty
        if (head == null)
            return head;

        Node curr = head;

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

        // If the position is out of range
        if (curr == null)
            return head;

        // Update the previous node's next pointer
        if (curr.prev != null)
            curr.prev.next = curr.next;

        // Update the next node's prev pointer
        if (curr.next != null)
            curr.next.prev = curr.prev;

        // If the node to be deleted is the head node
        if (head == curr)
            head = curr.next;

        // Deallocate memory for the deleted node
        // In C#, the garbage collector handles this automatically
        return head;
    }

    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.Data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main() {

        // Create a hardcoded doubly linked list:
        // 1 <-> 2 <-> 3
        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);
    }
}
JavaScript 
// JavaScript Program to delete node at a specific position
// in Doubly Linked List

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

// Function to delete a node at a specific position 
// in the doubly linked list
function delPos(head, pos) {

    // If the list is empty
    if (head === null)
        return head;

    let curr = head;

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

    // If the position is out of range
    if (curr === null)
        return head;

    // Update the previous node's next pointer
    if (curr.prev !== null)
        curr.prev.next = curr.next;

    // Update the next node's prev pointer
    if (curr.next !== null)
        curr.next.prev = curr.prev;

    // If the node to be deleted is the head node
    if (head === curr)
        head = curr.next;

    return head;
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data + " ");
        curr = curr.next;
    }
    console.log();
}

// Create a hardcoded doubly linked list:
// 1 <-> 2 <-> 3
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);

Output
1 3

Time Complexity: O(n), where n is the number of nodes in the doubly linked list.
Auxiliary Space: O(1)


Next Article
How to Create a Doubly Linked List in C?

A

Ayush Jauhari
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox