Insert a Node at a specific position in Doubly Linked List
Last Updated :
07 Aug, 2024
Given a Doubly Linked List, the task is to insert a new node at a specific position in the linked list.
Examples:
Input: Linked List = 1 <-> 2 <-> 4, newData = 3, position = 3
Output: Linked List = 1 <-> 2 <-> 3 <-> 4
Explanation: New node with data = 3 is inserted at position 3
Input: Linked List = 2 <-> 3, newData = 1, position = 1
Output: Linked List = 1 <-> 2 <-> 3
Explanation: New node with data = 1 is inserted at position 1
Approach:
The idea is to traverse the linked list to find the node at position - 1, say current node. If the position is valid, create a new node with the given data and update its pointers: Set the next pointer of new node to next of current node and previous pointer of new node to current node. Similarly, update next pointer of current node to the new node and prev pointer of new node’s next to the new node.
Insert node 3 at position 3 in Doubly Linked ListTo insert a new node at a specific position,
- If position = 1, create a new node and make it the head of the linked list and return it.
- Otherwise, traverse the list to reach the node at position – 1, say curr.
- If the position is valid, create a new node with given data, say new_node.
- Update the next pointer of new node to the next of current node and prev pointer of new node to current node, new_node->next = curr->next and new_node->prev = curr.
- Similarly, update next pointer of current node to the new node, curr->next = new_node.
- If the new node is not the last node, update prev pointer of new node’s next to the new node, new_node->next->prev = new_node.
C++
// C++ Program to insert a node at a given position
#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 at a given position
Node *insertAtPosition(Node *head, int pos, int new_data) {
// Create a new node
Node *new_node = new Node(new_data);
// Insertion at the beginning
if (pos == 1) {
new_node->next = head;
// If the linked list is not empty, set the prev of head to new node
if (head != NULL)
head->prev = new_node;
// Set the new node as the head of linked list
head = new_node;
return head;
}
Node *curr = head;
// Traverse the list to find the node before the
// insertion point
for (int i = 1; i < pos - 1 && curr != NULL; ++i) {
curr = curr->next;
}
// If the position is out of bounds
if (curr == NULL) {
cout << "Position is out of bounds." << endl;
delete new_node;
return head;
}
// Set the prev of new node to curr
new_node->prev = curr;
// Set the new of new node to next of curr
new_node->next = curr->next;
// Update the next of current node to new node
curr->next = new_node;
// If the new node is not the last node, update prev of next node to new node
if (new_node->next != NULL)
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 != NULL) {
cout << curr->data << " ";
curr = curr->next;
}
cout << endl;
}
int main() {
// Create a harcoded doubly linked list:
// 1 <-> 2 <-> 4
Node *head = new Node(1);
head->next = new Node(2);
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 new node with data 3 at position 3
cout << "Inserting Node with data 3 at position 3: ";
int data = 3;
int pos = 3;
head = insertAtPosition(head, pos, data);
// Print the updated list
printList(head);
return 0;
}
// C Program to insert a node at a given position
#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 at a given position
struct Node* insertAtPosition(struct Node *head, int pos, int new_data) {
// Create a new node
struct Node *new_node = createNode(new_data);
// Insertion at the beginning
if (pos == 1) {
new_node->next = head;
// If the linked list is not empty, set the prev of head to new node
if (head != NULL) {
head->prev = new_node;
}
// Set the new node as the head of linked list
head = new_node;
return head;
}
struct Node *curr = head;
// Traverse the list to find the node before the insertion point
for (int i = 1; i < pos - 1 && curr != NULL; ++i) {
curr = curr->next;
}
// If the position is out of bounds
if (curr == NULL) {
printf("Position is out of bounds.\n");
free(new_node);
return head;
}
// Set the prev of new node to curr
new_node->prev = curr;
// Set the next of new node to next of curr
new_node->next = curr->next;
// Update the next of current node to new node
curr->next = new_node;
// If the new node is not the last node, update the prev of next node to new node
if (new_node->next != NULL) {
new_node->next->prev = new_node;
}
// Return the head of the doubly linked list
return head;
}
// Function to print the 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 <-> 2 <-> 4
struct Node *head = createNode(1);
head->next = createNode(2);
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 new node with data 3 at position 3
printf("Inserting Node with data 3 at position 3: ");
int data = 3;
int pos = 3;
head = insertAtPosition(head, pos, data);
// Print the updated list
printList(head);
return 0;
}
// Java Program to insert a node at a given position
class Node {
int data;
Node next;
Node prev;
Node(int new_data) {
data = new_data;
next = prev = null;
}
}
public class GFG {
// Function to insert a new node at a given position
public static Node insertAtPosition(Node head, int pos, int new_data) {
// Create a new node
Node new_node = new Node(new_data);
// Insertion at the beginning
if (pos == 1) {
new_node.next = head;
// If the linked list is not empty, set the prev of head to new node
if (head != null) {
head.prev = new_node;
}
// Set the new node as the head of linked list
head = new_node;
return head;
}
Node curr = head;
// Traverse the list to find the node before the insertion point
for (int i = 1; i < pos - 1 && curr != null; ++i) {
curr = curr.next;
}
// If the position is out of bounds
if (curr == null) {
System.out.println("Position is out of bounds.");
return head;
}
// Set the prev of new node to curr
new_node.prev = curr;
// Set the next of new node to next of curr
new_node.next = curr.next;
// Update the next of current node to new node
curr.next = new_node;
// If the new node is not the last node, update prev of next node to new node
if (new_node.next != null) {
new_node.next.prev = new_node;
}
// Return the head of the doubly linked list
return head;
}
// Function to print the 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 <-> 2 <-> 4
Node head = new Node(1);
head.next = new Node(2);
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 new node with data 3 at position 3
System.out.print("Inserting Node with data 3 at position 3: ");
int data = 3;
int pos = 3;
head = insertAtPosition(head, pos, data);
// Print the updated list
printList(head);
}
}
# Python Program to insert a node at a given position
class Node:
def __init__(self, new_data):
self.data = new_data
self.next = None
self.prev = None
def insert_at_position(head, pos, new_data):
# Create a new node
new_node = Node(new_data)
# Insertion at the beginning
if pos == 1:
new_node.next = head
# If the linked list is not empty, set the prev of head to new node
if head is not None:
head.prev = new_node
# Set the new node as the head of the linked list
head = new_node
return head
curr = head
# Traverse the list to find the node before the insertion point
for _ in range(1, pos - 1):
if curr is None:
print("Position is out of bounds.")
return head
curr = curr.next
# If the position is out of bounds
if curr is None:
print("Position is out of bounds.")
return head
# Set the prev of new node to curr
new_node.prev = curr
# Set the next of new node to next of curr
new_node.next = curr.next
# Update the next of current node to new node
curr.next = new_node
# If the new node is not the last node, update prev of next node to 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(curr.data, end=" ")
curr = curr.next
print()
if __name__ == "__main__":
# Create a hardcoded doubly linked list:
# 1 <-> 2 <-> 4
head = Node(1)
head.next = Node(2)
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 new node with data 3 at position 3
print("Inserting Node with data 3 at position 3: ", end="")
data = 3
pos = 3
head = insert_at_position(head, pos, data)
# Print the updated list
print_list(head)
// C# Program to insert a node at a given position
using System;
class Node {
public int Data;
public Node Next;
public Node Prev;
public Node(int data) {
Data = data;
Next = null;
Prev = null;
}
}
class GFG {
// Function to insert a new node at a given position
static Node InsertAtPosition(Node head, int pos, int newData) {
// Create a new node
Node newNode = new Node(newData);
// Insertion at the beginning
if (pos == 1) {
newNode.Next = head;
if (head != null)
head.Prev = newNode;
head = newNode;
return head;
}
Node curr = head;
// Traverse the list to find the node before the insertion point
for (int i = 1; i < pos - 1 && curr != null; ++i) {
curr = curr.Next;
}
// If the position is out of bounds
if (curr == null) {
Console.WriteLine("Position is out of bounds.");
return head;
}
// Set the prev of new node to curr
newNode.Prev = curr;
// Set the next of new node to the next of curr
newNode.Next = curr.Next;
// Update the next of current node to new node
curr.Next = newNode;
// If the new node is not the last node, update prev of next node to new node
if (newNode.Next != null)
newNode.Next.Prev = newNode;
return head;
}
// Function to print the list
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 <-> 4
Node head = new Node(1);
head.Next = new Node(2);
head.Next.Prev = head;
head.Next.Next = new Node(4);
head.Next.Next.Prev = head.Next;
// Print the original list
Console.WriteLine("Original Linked List: ");
PrintList(head);
// Insert new node with data 3 at position 3
Console.WriteLine("Inserting Node with data 3 at position 3: ");
head = InsertAtPosition(head, 3, 3);
// Print the updated list
PrintList(head);
}
}
// Javascript Program to insert a node at a given position
class Node {
constructor(data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
// Function to insert a new node at a given position
function insertAtPosition(head, pos, newData) {
// Create a new node
let newNode = new Node(newData);
// Insertion at the beginning
if (pos === 1) {
newNode.next = head;
if (head !== null) {
head.prev = newNode;
}
head = newNode;
return head;
}
let curr = head;
// Traverse the list to find the node before the insertion point
for (let i = 1; i < pos - 1 && curr !== null; ++i) {
curr = curr.next;
}
// If the position is out of bounds
if (curr === null) {
console.log("Position is out of bounds.");
return head;
}
// Set the prev of new node to curr
newNode.prev = curr;
// Set the next of new node to the next of curr
newNode.next = curr.next;
// Update the next of current node to new node
curr.next = newNode;
// If the new node is not the last node, update prev of next node to new node
if (newNode.next !== null) {
newNode.next.prev = newNode;
}
return head;
}
// Function to print the list
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 <-> 4
let head = new Node(1);
head.next = new Node(2);
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 new node with data 3 at position 3
console.log("Inserting Node with data 3 at position 3:");
head = insertAtPosition(head, 3, 3);
// Print the updated list
printList(head);
OutputOriginal Linked List: 1 2 4
Inserting Node with data 3 at position 3: 1 2 3 4
Time Complexity: O(N), where N is the number of nodes in doubly linked list
Auxiliary Space: O(1)
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Array Data Structure Guide In this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
4 min read
Sorting Algorithms A Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read