# Insert a value in a sorted way in a sorted Doubly Linked List

### Introduction

The linked list is one of the most important concepts and data structures to learn while preparing for interviews. Having a good grasp of Linked Lists can be a huge plus point in a coding interview.

### Problem Statement

In this problem, we are given a sorted Doubly Linked List and we need to insert a value in the list at its correct sorted position.

### Problem Statement Understanding

According to the problem statement, we need to insert a node with a value X in the sorted Doubly Linked List such that the resultant list after insertion is also sorted.

Let’s try to understand the problem statement with the help of examples.

If the given Sorted doubly linked list is: X = 8

• We can see that 8 is greater than 4, 5, 7 and smaller than 9, 12, 17, 19, so we will insert 8 after 7 and before 9 in the given linked list.
• The output Linked list after inserting 8 will be : If the given list is: head -> 1 4 9 11 13 22 and X = 3.

• In this case after inserting the node with value X = 3 at its correct position in linked list our output linked list will be : head -> 1 3 4 9 11 13 22.
##### Some more examples
• Sample Input 1: head -> 2 4 6 8 10, X = 5
• Sample Output 1: head -> 2 4 5 6 8 10
• Sample Input 2: head -> 1 3 5 9 11 13, X = 7
• Sample Output 2: head -> 1 3 5 7 9 11 13

Now I think from the above example, the problem statement is clear. So let's see how we will approach it.

Before moving to the approach section, try to think about how you can approach this problem.

• If stuck, no problem, we will thoroughly see how we can approach the problem in the next section.

Let’s move to the approach section.

### Approach

The approach will be simple:

• In order to insert a node with value X in a sorted list in sorted order, we need to traverse the list till the data of the next node of current is smaller than the given value X.
• After reaching the correct position, we will simply insert a new node with value X over there.
• This method is the same for both singly and doubly list. The only difference is that in Doubly Linked List, we have to take care of the prev pointer along with the next pointer.

### Algorithm

• If the head is null, that means the list is empty. newNode (Node with value X, which we want to insert in the list) is the only node in the list. Make it head and return head.
• Else if head->data >= newNode.data, that means the newNode needs to be inserted at the beginning.
• Else:
• Initialize pointer variable current with head node.
• We will start traversing the linked list using pointer current.
• While traversing, if we encounter current->next->data greater than the X, i.e., the value of newNode which we have to insert is smaller than current->next->data, then we need to insert the given node at that position by following below steps:
• Make next of newNode (node that needs to be inserted) equal to next of current node (newNode->next = current.next).
• If next of current is not null, i.e., newNode not inserted at end, make newNode->next->prev = newNode.
• Make next of current node as newNode (current->next = newNode).
• Make Prev of the newNode as current (newNode->prev = current).
• Finally, output the updated Doubly Linked List.

### Dry Run  ### Code Implementation:

```#include
using namespace std;

/* Node structure of our doubly linked list */
struct DLLNode {
int data;
struct DLLNode* prev, *next;
};

/* Using this function we will be creating and returning a new node of doubly linked list */
struct DLLNode* CreateNewNode(int data)
{
struct DLLNode* newNode = (struct DLLNode*)malloc(sizeof(struct DLLNode));
newNode->data = data;
newNode->prev = newNode->next = NULL;
return newNode;
}

/* This is the function using which we will be inserting a new node in a sorted doubly linked list in sorted way */
void InsertionSortedManner(struct DLLNode** head, struct DLLNode* newNode)
{
struct DLLNode* current;

}

else if ((*head)->data >= newNode->data) {
newNode->next->prev = newNode;
}

else {
while (current->next != NULL && 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;
}
}

/* Using this function we will be printing the doubly linked list */
{
cout << head->data << " ";
}
}

int main()
{
struct DLLNode* new_node = CreateNewNode(8);
new_node = CreateNewNode(5);
new_node = CreateNewNode(4);
new_node = CreateNewNode(7);
new_node = CreateNewNode(9);
new_node = CreateNewNode(19);
new_node = CreateNewNode(12);
new_node = CreateNewNode(17);

cout << "Doubly Linked List before insertion "<

```