Insert a Node after a given node in Doubly Linked List

Last Updated : 07 Aug, 2024

Given a Doubly Linked List, the task is to insert a new node after a given node in the linked list.

Examples:

Input: Linked List = 1 <-> 2 <-> 4, newData = 3, key = 2
Output: Linked List = 1 <-> 2 <-> 3 <-> 4
Explanation: New node 3 is inserted after key, that is node 2.
Input: Linked List = 1 <-> 2, newData = 4, key = 2
Output: Linked List = 1 <-> 2 <-> 4
Explanation: New node 4 is inserted after key, that is node 2.

Approach: To solve the problem, follow the below idea:

To insert a new node after a given node, we first find the given node in the doubly linked list. If the given node is not found, return the original linked list. Otherwise if the given node is found, say current node, we create a new node with new data and update its pointers: Update the previous pointer of new node to the current node and the next pointer of new node to the current node' s next. Then, update the next pointer of current node to the new node. Finally, if the new node is not the last node of the linked list, then we update the update previous pointer of new node’s next node to new node.

Insertion-after-a-given-node-in-Doubly-Linked-List — Insert node 3 after given node 2 in Doubly Linked List

To insert a new node after a specific node,

Find the given node in the doubly linked list, say curr.
Once we find it, create a new node with the new data, say new_node.
Update the new node’s previous pointer to given node and new node’s next pointer to the given node’s next, new_node->prev = curr and new_node->next = curr->next.
Then, we update the next pointer of given node with new node, curr->next = new_node.
Also, if the new node is not the last node of the linked list, then update previous pointer of new node’s next node to new node, new_node->next->prev = new_node.

C++

// C++ Program to insert a node after a given node of doubly linked list  #include <bits/stdc++.h> using namespace std;  struct Node {     int data;     Node *next, *prev;      Node(int new_data) {         data = new_data;         next = prev = nullptr;     } };  // Function to insert a new node after a given node // in doubly linked list Node *insertAfter(Node *head, int key, int new_data) {      Node *curr = head;      // Iterate over Linked List to find the key     while (curr != nullptr) {         if (curr->data == key)             break;         curr = curr->next;     }      // if curr becomes null means, given key is not     // found in linked list     if (curr == nullptr)         return head;      // Create a new node     Node *new_node = new Node(new_data);      // Set prev of new node to given node     new_node->prev = curr;      // Set next of new node to next of given node     new_node->next = curr->next;      // Update next of given node to new node     curr->next = new_node;      // If the given node is not the last node of the linked list,    	// update the prev of new node's next with new node   	if(new_node->next != nullptr) {     	new_node->next->prev = new_node;     }      // Return the head of the doubly linked list     return head; }  void printList(Node *head) {      Node *curr = head;     while (curr != nullptr) {         cout << " " << curr->data;         curr = curr->next;     }     cout << endl; }  int main() {      // Create a harcoded doubly linked list:     // 1 <-> 3 <-> 4     Node *head = new Node(1);     head->next = new Node(3);     head->next->prev = head;     head->next->next = new Node(4);     head->next->next->prev = head->next;      // Print the original list     cout << "Original Linked List:";     printList(head);      // Insert a new node after node 1     cout << "Inserting Node with data 2 after node 1:";     int data = 2;     int key = 1;     head = insertAfter(head, key, data);      // Print the updated list     printList(head);      return 0; }

// C Program to insert a node after a given node of doubly linked list  #include <stdio.h>  struct Node {     int data;     struct Node *next;     struct Node *prev; };  // Function to create a new node with the given data struct Node *createNode(int new_data) {     struct Node *new_node = (struct Node *)malloc(sizeof(struct Node));     new_node->data = new_data;     new_node->next = NULL;     return new_node; }  // Function to insert a new node after a given node in doubly linked list struct Node *insertAfter(struct Node *head, int key, int new_data) {     struct Node *curr = head;      // Iterate over Linked List to find the key     while (curr != NULL) {         if (curr->data == key)             break;         curr = curr->next;     }      // If curr becomes NULL, the given key     // is not found in linked list     if (curr == NULL)         return head;      // Create a new node     struct Node *new_node = createNode(new_data);      // Set prev of new node to the given node     new_node->prev = curr;      // Set next of new node to the next of given node     new_node->next = curr->next;      // Update next of given node to new node     curr->next = new_node;      // Update the prev of new node's next with new node     if (new_node->next != NULL)         new_node->next->prev = new_node;      return head; }  // Function to print the doubly linked list void printList(struct Node *head) {     struct Node *curr = head;     while (curr != NULL) {         printf(" %d", curr->data);         curr = curr->next;     }     printf("\n"); }  int main() {      // Create a hardcoded doubly linked list:     // 1 <-> 3 <-> 4     struct Node *head = createNode(1);     head->next = createNode(3);     head->next->prev = head;     head->next->next = createNode(4);     head->next->next->prev = head->next;      // Print the original list     printf("Original Linked List:");     printList(head);      // Insert a new node after node with key 1     printf("Inserting Node with data 2 after node 1 :");     int data = 2;     int key = 1;     head = insertAfter(head, key, data);      // Print the updated list     printList(head);      return 0; }

Java

// Java Program to insert a node after a given node of doubly linked list  class Node {     int data;     Node next, prev;      Node(int newData) {         data = newData;         next = prev = null;     } }  public class GFG {      // Function to insert a new node after a given node in the doubly linked list     public static Node insertAfter(Node head, int key, int newData) {         Node curr = head;          // Iterate over Linked List to find the key         while (curr != null) {             if (curr.data == key)                 break;             curr = curr.next;         }          // If curr becomes null, the given key is not found in the linked list         if (curr == null)             return head;          // Create a new node         Node newNode = new Node(newData);          // Set prev of new node to the given node         newNode.prev = curr;          // Set next of new node to the next of the given node         newNode.next = curr.next;          // Update next of the given node to new node         curr.next = newNode;          // Update the prev of new node's next with the new node         if (newNode.next != null)             newNode.next.prev = newNode;          return head;     }      // Function to print the doubly linked list     public 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 <-> 3 <-> 4         Node head = new Node(1);         head.next = new Node(3);         head.next.prev = head;         head.next.next = new Node(4);         head.next.next.prev = head.next;          // Print the original list         System.out.print("Original Linked List:");         printList(head);          // Insert a new node after node with data 1         System.out.print("Inserting Node with data 2 after node 1 :");         int data = 2;         int key = 1;         head = insertAfter(head, key, data);          // Print the updated list         printList(head);     } }

Python

# Python Program to insert a node after a given node of doubly linked list  class Node:     def __init__(self, new_data):         self.data = new_data         self.next = None         self.prev = None  def insert_after(head, key, new_data):     curr = head      # Iterate over Linked List to find the key     while curr is not None:         if curr.data == key:             break         curr = curr.next      # If curr becomes None, the given key is not found in the linked list     if curr is None:         return head      # Create a new node     new_node = Node(new_data)      # Set prev of new node to the given node     new_node.prev = curr      # Set next of new node to the next of the given node     new_node.next = curr.next      # Update next of the given node to new node     curr.next = new_node      # Update the prev of new node's next with the new node     if new_node.next is not None:         new_node.next.prev = new_node      return head  def print_list(head):     curr = head     while curr is not None:         print(f" {curr.data}", end='')         curr = curr.next     print()  if __name__ == "__main__":        # Create a hardcoded doubly linked list:     # 1 <-> 3 <-> 4     head = Node(1)     head.next = Node(3)     head.next.prev = head     head.next.next = Node(4)     head.next.next.prev = head.next      # Print the original list     print("Original Linked List:", end='')     print_list(head)      # Insert a new node after node with data 1     print("Inserting Node with data 2 after node 1 :", end='')     data = 2     key = 1     head = insert_after(head, key, data)      # Print the updated list     print_list(head)

// C# Program to insert a node after a given node of doubly linked list  using System;  class Node {     public int Data;     public Node Next;     public Node Prev;      public Node(int newData) {         Data = newData;         Next = null;         Prev = null;     } }  class GFG {     static Node InsertAfter(Node head, int key, int newData) {         Node curr = head;          // Iterate over Linked List to find the key         while (curr != null) {             if (curr.Data == key)                 break;             curr = curr.Next;         }          // If curr becomes null, the given key is not found in the linked list         if (curr == null)             return head;          // Create a new node         Node newNode = new Node(newData);          // Set prev of new node to the given node         newNode.Prev = curr;          // Set next of new node to next of the given node         newNode.Next = curr.Next;          // Update next of the given node to the new node         curr.Next = newNode;          // Update the prev of new node's next with the new node         if (newNode.Next != null)             newNode.Next.Prev = newNode;          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 <-> 3 <-> 4         Node head = new Node(1);         head.Next = new Node(3);         head.Next.Prev = head;         head.Next.Next = new Node(4);         head.Next.Next.Prev = head.Next;          // Print the original list         Console.Write("Original Linked List:");         PrintList(head);          // Insert a new node after node with data 1         Console.Write("Inserting Node with data 2 after node 1 :");         int data = 2;         int key = 1;         head = InsertAfter(head, key, data);          // Print the updated list         PrintList(head);     } }

JavaScript

// Javascript Program to insert a node after a given node of doubly linked list  class Node {     constructor(data) {         this.data = data;         this.next = null;         this.prev = null;     } }  // Function to insert a new node after a given node in the doubly linked list function insertAfter(head, key, newData) {     let curr = head;      // Iterate over Linked List to find the key     while (curr !== null) {         if (curr.data === key) {             break;         }         curr = curr.next;     }      // If curr becomes null, the given key is not found in     // the linked list     if (curr === null) {         return head;     }      // Create a new node     const newNode = new Node(newData);      // Set prev of new node to the given node     newNode.prev = curr;      // Set next of new node to next of the given node     newNode.next = curr.next;      // Update next of the given node to the new node     curr.next = newNode;      // Update the prev of new node's next with the new node     if (newNode.next !== null) {         newNode.next.prev = newNode;     }      return head; }  function printList(head) {     let curr = head;     let result = "";     while (curr !== null) {         result += curr.data + " ";         curr = curr.next;     }     console.log(result); }  // Create a hardcoded doubly linked list: // 1 <-> 3 <-> 4  const head = new Node(1); head.next = new Node(3); head.next.prev = head; head.next.next = new Node(4); head.next.next.prev = head.next;  // Print the original list console.log("Original Linked List:"); printList(head);  // Insert a new node after node with data 1 console.log("Inserting Node with data 2 after node 1:"); const data = 2; const key = 1; insertAfter(head, key, data);  // Print the updated list printList(head);

Output

Original Linked List: 1 3 4 Inserting Node with data 2 after node 1: 1 2 3 4

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

Insert a Node at a specific position in Doubly Linked List

mrityuanjay8vae

Improve

Article Tags :

Practice Tags :

Linked List

Insert a Node after a given node in Doubly Linked List

Similar Reads