Insert value in sorted way in a sorted doubly linked list
Last Updated :
04 Sep, 2024
Given a Sorted Doubly Linked List in (non-decreasing order) and an element x, the task is to insert the element x into the correct position in the Sorted Doubly Linked List.
Example:
Input: LinkedList = 3<->5<->8<->10<->12 , x = 9
Output: 3<->5<->8<->9<->10<->12
Explanation: Here node 9 is inserted between 8 and 10 in the Doubly Linked-List.
Input: LinkedList = 1<->4<->10<->11 , x = 15
Output: 1<->4<->10<->11<->15
Explanation: Here node 15 is inserted at end in the Doubly Linked-List.
Approach:
To insert a value into a sorted doubly linked list while maintaining sorted order, start by creating a new node with the given value.
- If the list is empty, new node becomes the head of the doubly linked list.
- else If the new node's value is smaller than or equal to the head's value, insert it at the beginning.
- else, traverse the list to find the correct position where the new node’s value is greater than the current node and smaller than the next node. Adjust pointers to insert the node between the current and next node or after the current node (if curr's next is NULL) .
C++
// C++ implementation to insert value in sorted way
// in a sorted doubly linked list
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* prev;
Node* next;
Node(int new_data) {
data = new_data;
prev = nullptr;
next = nullptr;
}
};
// Function to insert element x into sorted DLL
Node* sortedInsert(Node* head, int x) {
// Create a new node with the given data
Node* newNode = new Node(x);
// If the list is empty, set new node as the head
if (head == nullptr) {
return newNode;
}
// If new node needs to be inserted at beginning
if (x <= head->data) {
newNode->next = head;
head->prev = newNode;
return newNode;
}
// Traverse the list to find correct position
Node* curr = head;
while (curr->next != nullptr && curr->next->data < x) {
curr = curr->next;
}
// Insert the new node in the correct position
newNode->next = curr->next;
if (curr->next != nullptr) {
curr->next->prev = newNode;
}
curr->next = newNode;
newNode->prev = curr;
return head;
}
void printList(Node* curr) {
while (curr != nullptr) {
cout << curr->data << " ";
curr = curr->next;
}
}
int main() {
// Create hardcoded DLL:
// 3 <-> 5 <-> 8 <-> 10 <-> 12
Node* head = new Node(3);
head->next = new Node(5);
head->next->prev = head;
head->next->next = new Node(8);
head->next->next->prev = head->next;
head->next->next->next = new Node(10);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = new Node(12);
head->next->next->next->next->prev =
head->next->next->next;
int x = 9;
head = sortedInsert(head, x);
printList(head);
return 0;
}
// C implementation to insert value in sorted way
// in a sorted doubly linked list
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *prev, *next;
};
struct Node *createNode(int data);
// Function to insert an element x into the correct
// position in a sorted doubly linked list
struct Node *sortedInsert(struct Node *head, int x) {
// Create a new node with the given data
struct Node *newNode = createNode(x);
// If the list is empty, return the new node
// as the head
if (head == NULL) {
return newNode;
}
// If the new node needs to be inserted at the
// beginning
if (x <= head->data) {
newNode->next = head;
head->prev = newNode;
return newNode;
}
// Traverse the list to find the correct position
// to insert the new node
struct Node *curr = head;
while (curr->next != NULL && curr->next->data < x) {
curr = curr->next;
}
// Insert the new node in the
// correct position
newNode->next = curr->next;
if (curr->next != NULL) {
curr->next->prev = newNode;
}
curr->next = newNode;
newNode->prev = curr;
return head;
}
void printList(struct Node *curr) {
while (curr != NULL) {
printf("%d ", curr->data);
curr = curr->next;
}
}
struct Node *createNode(int data) {
struct Node *newNode =
(struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->prev = newNode->next = NULL;
return newNode;
}
int main() {
// Create a hardcoded doubly linked list:
// 3 <-> 5 <-> 8 <-> 10 <-> 12
struct Node *head = createNode(3);
head->next = createNode(5);
head->next->prev = head;
head->next->next = createNode(8);
head->next->next->prev = head->next;
head->next->next->next = createNode(10);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = createNode(12);
head->next->next->next->next->prev = head->next->next->next;
int x = 9;
head = sortedInsert(head, x);
printList(head);
return 0;
}
// Java implementation to insert value in sorted way
// in a sorted doubly linked list
class Node {
int data;
Node prev, next;
Node(int data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
public class GfG {
// Function to insert an element x into the
// correct position in a sorted doubly linked list
static Node sortedInsert(Node head, int x) {
// Create a new node with the given data
Node newNode = new Node(x);
// If the list is empty, return the new node
// as the head
if (head == null) {
return newNode;
}
// If the new node needs to be inserted at
// the beginning
if (x <= head.data) {
newNode.next = head;
head.prev = newNode;
return newNode;
}
// Traverse the list to find the correct
// position to insert the new node
Node curr = head;
while (curr.next != null && curr.next.data < x) {
curr = curr.next;
}
// Insert the new node in the correct position
newNode.next = curr.next;
if (curr.next != null) {
curr.next.prev = newNode;
}
curr.next = newNode;
newNode.prev = curr;
return head;
}
static void printList(Node curr) {
while (curr != null) {
System.out.print(curr.data + " ");
curr = curr.next;
}
}
public static void main(String[] args) {
// Create a hardcoded doubly linked list:
// 3 <-> 5 <-> 8 <-> 10 <-> 12
Node head = new Node(3);
head.next = new Node(5);
head.next.prev = head;
head.next.next = new Node(8);
head.next.next.prev = head.next;
head.next.next.next = new Node(10);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(12);
head.next.next.next.next.prev =
head.next.next.next;
int x = 9;
head = sortedInsert(head, x);
printList(head);
}
}
# Python implementation to insert value in sorted way
# in a sorted doubly linked list
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
# Function to insert an element x into the correct
# position in a sorted doubly linked list
def sorted_insert(head, x):
# Create a new node with the given data
new_node = Node(x)
# If the list is empty, return the new node
# as the head
if head is None:
return new_node
# If the new node needs to be inserted at
# the beginning
if x <= head.data:
new_node.next = head
head.prev = new_node
return new_node
# Traverse the list to find the correct
# position to insert the new node
curr = head
while curr.next is not None and curr.next.data < x:
curr = curr.next
# Insert the new node in the correct position
new_node.next = curr.next
if curr.next is not None:
curr.next.prev = new_node
curr.next = new_node
new_node.prev = curr
return head
def print_list(curr):
while curr is not None:
print(curr.data, end=" ")
curr = curr.next
print()
if __name__ == "__main__":
# Create a hardcoded doubly linked list:
# 3 <-> 5 <-> 8 <-> 10 <-> 12
head = Node(3)
head.next = Node(5)
head.next.prev = head
head.next.next = Node(8)
head.next.next.prev = head.next
head.next.next.next = Node(10)
head.next.next.next.prev = head.next.next
head.next.next.next.next = Node(12)
head.next.next.next.next.prev = head.next.next.next
x = 9
head = sorted_insert(head, x)
print_list(head)
// C# implementation to insert value in sorted way
// in a sorted doubly linked list
using System;
class Node {
public int data;
public Node prev, next;
public Node(int data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
class GfG {
// Function to insert an element x into the
// correct position in a sorted doubly linked list
static Node SortedInsert(Node head, int x) {
// Create a new node with the given data
Node newNode = new Node(x);
// If the list is empty, return the new node
// as the head
if (head == null) {
return newNode;
}
// If the new node needs to be inserted at
// the beginning
if (x <= head.data) {
newNode.next = head;
head.prev = newNode;
return newNode;
}
// Traverse the list to find the correct
// position to insert the new node
Node curr = head;
while (curr.next != null && curr.next.data < x) {
curr = curr.next;
}
// Insert the new node in the correct position
newNode.next = curr.next;
if (curr.next != null) {
curr.next.prev = newNode;
}
curr.next = newNode;
newNode.prev = curr;
return head;
}
static void PrintList(Node curr) {
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
static void Main() {
// Create a hardcoded doubly linked list:
// 3 <-> 5 <-> 8 <-> 10 <-> 12
Node head = new Node(3);
head.next = new Node(5);
head.next.prev = head;
head.next.next = new Node(8);
head.next.next.prev = head.next;
head.next.next.next = new Node(10);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(12);
head.next.next.next.next.prev = head.next.next.next;
int x = 9;
head = SortedInsert(head, x);
PrintList(head);
}
}
// JavaScript implementation to insert value
// in sorted way in a sorted doubly linked list
class Node {
constructor(data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
// Function to insert an element x into the correct
// position in a sorted doubly linked list
function sortedInsert(head, x) {
// Create a new node with the given data
const newNode = new Node(x);
// If the list is empty, return the new node
// as the head
if (head === null) {
return newNode;
}
// If the new node needs to be inserted at
// the beginning
if (x <= head.data) {
newNode.next = head;
head.prev = newNode;
return newNode;
}
// Traverse the list to find the correct
// position to insert the new node
let curr = head;
while (curr.next !== null && curr.next.data < x) {
curr = curr.next;
}
// Insert the new node in the correct position
newNode.next = curr.next;
if (curr.next !== null) {
curr.next.prev = newNode;
}
curr.next = newNode;
newNode.prev = curr;
return head;
}
function printList(curr) {
while (curr !== null) {
process.stdout.write(curr.data + " ");
curr = curr.next;
}
console.log();
}
// Create a hardcoded doubly linked list:
// 3 <-> 5 <-> 8 <-> 10 <-> 12
let head = new Node(3);
head.next = new Node(5);
head.next.prev = head;
head.next.next = new Node(8);
head.next.next.prev = head.next;
head.next.next.next = new Node(10);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(12);
head.next.next.next.next.prev = head.next.next.next;
const x = 9;
head = sortedInsert(head, x);
printList(head);
Time Complexity: O(n) , where n is the number of nodes in the linked lsit.
Auxiliary Space: O(1)
Similar Reads
Sorted insert in a doubly linked list with head and tail pointers A Doubly linked list is a linked list that consists of a set of sequentially linked records called nodes. Each node contains two fields that are references to the previous and to the next node in the sequence of nodes. The task is to create a doubly linked list by inserting nodes such that list rema
10 min read
Insert a Node after a given node in Doubly Linked List 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 = 2Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node 3 is inserted after key, that is node 2.In
11 min read
Given a linked list which is sorted, how will you insert in sorted way Given a sorted linked list and a value to insert, write a function to insert the value in a sorted way.Initial Linked List Linked List after insertion of 9 Recommended PracticeInsert in a Sorted ListTry It! Algorithm: Let input linked list is sorted in increasing order. 1) If Linked list is empty th
14 min read
Insert a Node before a given node in Doubly Linked List Given a Doubly Linked List, the task is to insert a new node before a given node in the linked list.Examples: Input: Linked List = 1 <-> 3 <-> 4, newData = 2, key = 3Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node with data 2 is inserted before the node w
12 min read
Insert a Node at the end of Doubly Linked List Given a Doubly Linked List, the task is to insert a new node at the end of the linked list.Examples: Input: Linked List = 1 <-> 2 <-> 3, NewNode = 4Output: Linked List = 1 <-> 2 <-> 3 <-> 4Input: Linked List = NULL, NewNode = 1Output: Linked List = 1Approach: Inserting
9 min read