Insert value in sorted way in a sorted doubly linked list

Given a Sorted Doubly Linked List in non-decreasing order and an element x, insert the element x into its correct position in the Sorted Doubly Linked List so that the list remains sorted.

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.

Try It Yourself

[Approach] Linear Traversal – O(n) Time and O(1) Space

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++

#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;
}

#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

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

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 sortedInsert(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 = sortedInsert(head, x)
    print_list(head)

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

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);

Output

3 5 8 9 10 12

Insert value in sorted way in a sorted doubly linked list

[Approach] Linear Traversal – O(n) Time and O(1) Space

Explore