Insert value in sorted way in a sorted doubly linked list

Last Updated : 10 Jan, 2023

Given a sorted doubly linked list and a value to insert, write a function to insert the value in sorted way.
Initial doubly linked list

Doubly Linked List after insertion of 9

Algorithm:

Let input doubly linked list is sorted in increasing order. New node passed to the function contains data in the data part and previous and next link are set to NULL.

sortedInsert(head_ref, newNode)
      if (head_ref == NULL)
      head_ref = newNode
        
      else if head_ref->data >= newNode->data
          newNode->next = head_ref
      newNode->next->prev = newNode
      head_ref = newNode    
        
      else
      Initialize current = head_ref
      while (current->next != NULL and
               current->next->data < newNode->data)
        current = current->next
        
      newNode->next = current->next
      if current->next != NULL
        newNode->next->prev = newNode
            
          current->next = newNode
      newNode->prev = current

Implementation:

C++

// C++ implementation to insert value in sorted way 
// in a sorted doubly linked list 
#include <bits/stdc++.h> 
  
using namespace std; 
  
// Node of a doubly linked list 
struct Node { 
    int data; 
    struct Node* prev, *next; 
}; 
  
// function to create and return a new node 
// of a doubly linked list 
struct Node* getNode(int data) 
{ 
    // allocate node 
    struct Node* newNode =  
        (struct Node*)malloc(sizeof(struct Node)); 
  
    // put in the data 
    newNode->data = data; 
    newNode->prev = newNode->next = NULL; 
    return newNode; 
} 
  
// function to insert a new node in sorted way in 
// a sorted doubly linked list 
void sortedInsert(struct Node** head_ref, struct Node* newNode) 
{ 
    struct Node* current; 
  
    // if list is empty 
    if (*head_ref == NULL) 
        *head_ref = newNode; 
  
    // if the node is to be inserted at the beginning 
    // of the doubly linked list 
    else if ((*head_ref)->data >= newNode->data) { 
        newNode->next = *head_ref; 
        newNode->next->prev = newNode; 
        *head_ref = newNode; 
    } 
  
    else { 
        current = *head_ref; 
  
        // locate the node after which the new node 
        // is to be inserted 
        while (current->next != NULL &&  
               current->next->data < newNode->data) 
            current = current->next; 
  
        /* Make the appropriate links */
        newNode->next = current->next; 
  
        // if the new node is not inserted 
        // at the end of the list 
        if (current->next != NULL) 
            newNode->next->prev = newNode; 
  
        current->next = newNode; 
        newNode->prev = current; 
    } 
} 
  
// function to print the doubly linked list 
void printList(struct Node* head) 
{ 
    while (head != NULL) { 
        cout << head->data << " "; 
        head = head->next; 
    } 
} 
  
// Driver program to test above 
int main() 
{ 
    /* start with the empty doubly linked list */
    struct Node* head = NULL; 
  
    // insert the following nodes in sorted way 
    struct Node* new_node = getNode(8); 
    sortedInsert(&head, new_node); 
    new_node = getNode(5); 
    sortedInsert(&head, new_node); 
    new_node = getNode(3); 
    sortedInsert(&head, new_node); 
    new_node = getNode(10); 
    sortedInsert(&head, new_node); 
    new_node = getNode(12); 
    sortedInsert(&head, new_node); 
    new_node = getNode(9); 
    sortedInsert(&head, new_node); 
  
    cout << "Created Doubly Linked Listn"; 
    printList(head); 
    return 0; 
} 

Java

// Java implementation to insert value in sorted way  
// in a sorted doubly linked list  
import java.io.*; 
import java.util.*; 
  
// Node of a doubly linked list 
class Node  
{ 
    int data; 
    Node next, prev; 
} 
  
class GFG 
{ 
  
    // function to create and return a new node  
    // of a doubly linked list  
    static Node getNode(int data)  
    { 
            // allocate node  
            Node newNode = new Node(); 
  
            // put in the data  
            newNode.data = data;  
            newNode.prev = newNode.next = null;  
            return newNode;  
  
    } 
  
    // function to insert a new node in sorted way in  
    // a sorted doubly linked list  
    static Node sortedInsert(Node head, Node newNode) 
    { 
            Node current; 
  
            // if list is empty  
            if (head == null) 
                head = newNode;  
  
            // if the node is to be inserted at the beginning  
            // of the doubly linked list  
            else if (head.data >= newNode.data) 
            { 
                newNode.next = head; 
                newNode.next.prev = newNode; 
                head = newNode; 
            } 
  
            else 
            { 
                current = head; 
  
                // locate the node after which the new node  
                // is to be inserted  
                while (current.next != null &&  
                        current.next.data < newNode.data)  
                    current = current.next; 
  
                /* Make the appropriate links */
                newNode.next = current.next; 
  
                // if the new node is not inserted  
                // at the end of the list 
                if (current.next != null)  
                    newNode.next.prev = newNode;  
  
                current.next = newNode;  
                newNode.prev = current;  
              
            } 
            return head; 
    } 
  
    // function to print the doubly linked list  
    static void printList(Node head) 
    { 
            while (head != null)  
            { 
                    System.out.print(head.data + " "); 
                    head = head.next; 
            } 
  
    } 
  
    // Driver code 
    public static void main(String args[]) 
    { 
            /* start with the empty doubly linked list */
            Node head = null; 
  
            // insert the following nodes in sorted way 
            Node new_node = getNode(8); 
            head = sortedInsert(head, new_node);  
            new_node = getNode(5);  
            head = sortedInsert(head, new_node);  
            new_node = getNode(3);  
            head = sortedInsert(head, new_node);  
            new_node = getNode(10);  
            head = sortedInsert(head, new_node);  
            new_node = getNode(12);  
            head = sortedInsert(head, new_node);  
            new_node = getNode(9);  
            head = sortedInsert(head, new_node); 
  
            System.out.println("Created Doubly Linked List"); 
            printList(head); 
    } 
} 
  
// This code is contributed by rachana soma 

Python3

# Python3 implementation to insert 
# value in sorted way in a sorted 
# doubly linked list 
  
# Node of a doubly linked list 
class Node: 
  
    # Constructor to initialize  
    # the node object 
    def __init__(self, data): 
          
        self.data = data 
        self.next = None
        self.prev = None
  
class DoublyLinkedList: 
  
    # Function to initialize head 
    def __init__(self): 
          
        self.head = None
  
    # Function to create and return a  
    # new node of a doubly linked list 
    def getNode(self, data): 
          
        return Node(data) 
  
    # Function to insert a new node in  
    # sorted way in a sorted doubly linked list 
    def sortedInsert(self, data): 
          
        new_node = self.getNode(data) 
  
        # If the list is empty 
        if self.head is None: 
            self.head = new_node 
          
        # If the node is to be inserted at   
        # the beginning of the doubly linked list  
        elif self.head.data >= new_node.data: 
            new_node.next = self.head 
            new_node.next.prev = new_node 
            self.head = new_node 
        else:  
            current = self.head 
  
            # Locate the node after which  
            # the new node  is to be inserted 
            while ((current.next is not None) and 
                   (current.next.data < new_node.data)): 
                current = current.next
      
            # Make the appropriate links 
            new_node.next = current.next
  
            # If the new node is not inserted  
            # at the end of the list 
            if current.next is not None: 
                new_node.next.prev = new_node 
  
            current.next = new_node 
            new_node.prev = current 
      
    # Function to print the doubly linked list 
    def printList(self): 
  
        node = self.head 
        while node: 
            print(str(node.data), end = " ") 
            node = node.next
  
# Driver code 
if __name__ == '__main__': 
  
    # Insert the following nodes 
    # in sorted way  
    llist = DoublyLinkedList() 
    llist.sortedInsert(8) 
    llist.sortedInsert(5) 
    llist.sortedInsert(3) 
    llist.sortedInsert(10) 
    llist.sortedInsert(12) 
    llist.sortedInsert(9) 
      
    print("Created Doubly Linked List") 
    llist.printList() 
  
# This code is contributed by Siddhartha Pramanik 

C#

// C# implementation to insert value in sorted way  
// in a sorted doubly linked list  
using System;  
  
// Node of a doubly linked list  
public class Node  
{  
    public int data;  
    public Node next, prev;  
}  
  
class GFG  
{  
  
    // function to create and return a new node  
    // of a doubly linked list  
    static Node getNode(int data)  
    {  
        // allocate node  
        Node newNode = new Node();  
  
        // put in the data  
        newNode.data = data;  
        newNode.prev = newNode.next = null;  
        return newNode;  
  
    }  
  
    // function to insert a new node in sorted way in  
    // a sorted doubly linked list  
    static Node sortedInsert(Node head, Node newNode)  
    {  
        Node current;  
  
        // if list is empty  
        if (head == null)  
            head = newNode;  
  
        // if the node is to be inserted at the beginning  
        // of the doubly linked list  
        else if (head.data >= newNode.data)  
        {  
            newNode.next = head;  
            newNode.next.prev = newNode;  
            head = newNode;  
        }  
  
        else
        {  
            current = head;  
  
            // locate the node after which the new node  
            // is to be inserted  
            while (current.next != null &&  
                    current.next.data < newNode.data)  
                current = current.next;  
  
            /* Make the appropriate links */
            newNode.next = current.next;  
  
            // if the new node is not inserted  
            // at the end of the list  
            if (current.next != null)  
                newNode.next.prev = newNode;  
  
            current.next = newNode;  
            newNode.prev = current;  
          
        }  
        return head;  
    }  
  
    // function to print the doubly linked list  
    static void printList(Node head)  
    {  
        while (head != null)  
        {  
                Console.Write(head.data + " ");  
                head = head.next;  
        }  
  
    }  
  
    // Driver code  
    public static void Main(String []args)  
    {  
        /* start with the empty doubly linked list */
        Node head = null;  
  
        // insert the following nodes in sorted way  
        Node new_node = getNode(8);  
        head = sortedInsert(head, new_node);  
        new_node = getNode(5);  
        head = sortedInsert(head, new_node);  
        new_node = getNode(3);  
        head = sortedInsert(head, new_node);  
        new_node = getNode(10);  
        head = sortedInsert(head, new_node);  
        new_node = getNode(12);  
        head = sortedInsert(head, new_node);  
        new_node = getNode(9);  
        head = sortedInsert(head, new_node);  
  
        Console.WriteLine("Created Doubly Linked List");  
        printList(head);  
    }  
}  
  
// This code is contributed by Arnab Kundu 

Javascript

<script> 
// javascript implementation to insert value in sorted way  
// in a sorted doubly linked list  
// Node of a doubly linked list 
class Node 
{ 
constructor() 
{ 
     this.data = 0; 
     this.next = null, this.prev = null; 
     } 
} 
    // function to create and return a new node 
    // of a doubly linked list 
    function getNode(data) 
    { 
      
        // allocate node 
         newNode = new Node(); 
  
        // put in the data 
        newNode.data = data; 
        newNode.prev = newNode.next = null; 
        return newNode; 
  
    } 
  
    // function to insert a new node in sorted way in 
    // a sorted doubly linked list 
    function sortedInsert( head,  newNode)  
    { 
        var current; 
  
        // if list is empty 
        if (head == null) 
            head = newNode; 
  
        // if the node is to be inserted at the beginning 
        // of the doubly linked list 
        else if (head.data >= newNode.data)  
        { 
            newNode.next = head; 
            newNode.next.prev = newNode; 
            head = newNode; 
        } 
  
        else { 
            current = head; 
  
            // locate the node after which the new node 
            // is to be inserted 
            while (current.next != null && current.next.data < newNode.data) 
                current = current.next; 
  
            /* Make the appropriate links */
            newNode.next = current.next; 
  
            // if the new node is not inserted 
            // at the end of the list 
            if (current.next != null) 
                newNode.next.prev = newNode; 
  
            current.next = newNode; 
            newNode.prev = current; 
  
        } 
        return head; 
    } 
  
    // function to print the doubly linked list 
    function printList( head) { 
        while (head != null) { 
            document.write(head.data + " "); 
            head = head.next; 
        } 
    } 
  
    // Driver code 
      
        /* start with the empty doubly linked list */
         head = null; 
  
        // insert the following nodes in sorted way 
         new_node = getNode(8); 
        head = sortedInsert(head, new_node); 
        new_node = getNode(5); 
        head = sortedInsert(head, new_node); 
        new_node = getNode(3); 
        head = sortedInsert(head, new_node); 
        new_node = getNode(10); 
        head = sortedInsert(head, new_node); 
        new_node = getNode(12); 
        head = sortedInsert(head, new_node); 
        new_node = getNode(9); 
        head = sortedInsert(head, new_node); 
  
        document.write("Created Doubly Linked List<br/>"); 
        printList(head); 
  
// This code is contributed by umadevi9616 
</script> 

Output

Created Doubly Linked Listn3 5 8 9 10 12

Time Complexity: O(n)
Auxiliary Space: O(n)

Suggest improvement

Find pairs with given sum in doubly linked list

Remove duplicates from an unsorted doubly linked list

Share your thoughts in the comments

Types of Linked List

Basic operations on Linked List

Easy problems on Linked List

Medium problems on Linked List

Hard problems on Linked List