Sorted insert in a doubly linked list with head and tail pointers
Last Updated :
11 Jan, 2023
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 remains in ascending order on printing from left to right. Also, we need to maintain two pointers, head (points to first node) and tail (points to last node).
Examples:
Input : 40 50 10 45 90 100 95
Output :10 40 45 50 90 95 100
Input : 30 10 50 43 56 12
Output :10 12 30 43 50 56
Algorithm:
The task can be accomplished as:
- If Linked list is empty then make both the left and right pointers point to the node to be inserted and make its previous and next field point to NULL.
- If node to be inserted has value less than the value of first node of linked list then connect that node from previous field of first node.
- If node to be inserted has value more than the value of last node of linked list then connect that node from next field of last node.
- If node to be inserted has value in between the value of first and last node, then check for appropriate position and make connections.
Implementation:
C++
/* C++ program to insetail nodes in doubly
linked list such that list remains in
ascending order on printing from left
to right */
#include <bits/stdc++.h>
using namespace std;
// A linked list node
class Node
{
public:
Node *prev;
int info;
Node *next;
};
// Function to insetail new node
void nodeInsetail(Node **head,
Node **tail,
int key)
{
Node *p = new Node();
p->info = key;
p->next = NULL;
// If first node to be insetailed in doubly
// linked list
if ((*head) == NULL)
{
(*head) = p;
(*tail) = p;
(*head)->prev = NULL;
return;
}
// If node to be insetailed has value less
// than first node
if ((p->info) < ((*head)->info))
{
p->prev = NULL;
(*head)->prev = p;
p->next = (*head);
(*head) = p;
return;
}
// If node to be insetailed has value more
// than last node
if ((p->info) > ((*tail)->info))
{
p->prev = (*tail);
(*tail)->next = p;
(*tail) = p;
return;
}
// Find the node before which we need to
// insert p.
Node *temp = (*head)->next;
while ((temp->info) < (p->info))
temp = temp->next;
// Insert new node before temp
(temp->prev)->next = p;
p->prev = temp->prev;
temp->prev = p;
p->next = temp;
}
// Function to print nodes in from left to right
void printList(Node *temp)
{
while (temp != NULL)
{
cout << temp->info << " ";
temp = temp->next;
}
}
// Driver program to test above functions
int main()
{
Node *left = NULL, *right = NULL;
nodeInsetail(&left, &right, 30);
nodeInsetail(&left, &right, 50);
nodeInsetail(&left, &right, 90);
nodeInsetail(&left, &right, 10);
nodeInsetail(&left, &right, 40);
nodeInsetail(&left, &right, 110);
nodeInsetail(&left, &right, 60);
nodeInsetail(&left, &right, 95);
nodeInsetail(&left, &right, 23);
cout<<"Doubly linked list on printing"
" from left to right\n";
printList(left);
return 0;
}
// This is code is contributed by rathbhupendra
/* C program to insetail nodes in doubly
linked list such that list remains in
ascending order on printing from left
to right */
#include<stdio.h>
#include<stdlib.h>
// A linked list node
struct Node
{
struct Node *prev;
int info;
struct Node *next;
};
// Function to insetail new node
void nodeInsetail(struct Node **head,
struct Node **tail,
int key)
{
struct Node *p = new Node;
p->info = key;
p->next = NULL;
// If first node to be insetailed in doubly
// linked list
if ((*head) == NULL)
{
(*head) = p;
(*tail) = p;
(*head)->prev = NULL;
return;
}
// If node to be insetailed has value less
// than first node
if ((p->info) < ((*head)->info))
{
p->prev = NULL;
(*head)->prev = p;
p->next = (*head);
(*head) = p;
return;
}
// If node to be insetailed has value more
// than last node
if ((p->info) > ((*tail)->info))
{
p->prev = (*tail);
(*tail)->next = p;
(*tail) = p;
return;
}
// Find the node before which we need to
// insert p.
temp = (*head)->next;
while ((temp->info) < (p->info))
temp = temp->next;
// Insert new node before temp
(temp->prev)->next = p;
p->prev = temp->prev;
temp->prev = p;
p->next = temp;
}
// Function to print nodes in from left to right
void printList(struct Node *temp)
{
while (temp != NULL)
{
printf("%d ", temp->info);
temp = temp->next;
}
}
// Driver program to test above functions
int main()
{
struct Node *left = NULL, *right = NULL;
nodeInsetail(&left, &right, 30);
nodeInsetail(&left, &right, 50);
nodeInsetail(&left, &right, 90);
nodeInsetail(&left, &right, 10);
nodeInsetail(&left, &right, 40);
nodeInsetail(&left, &right, 110);
nodeInsetail(&left, &right, 60);
nodeInsetail(&left, &right, 95);
nodeInsetail(&left, &right, 23);
printf("\nDoubly linked list on printing"
" from left to right\n");
printList(left);
return 0;
}
/* Java program to insetail nodes in doubly
linked list such that list remains in
ascending order on printing from left
to right */
import java.io.*;
import java.util.*;
// A linked list node
class Node
{
int info;
Node prev, next;
}
class GFG
{
static Node head, tail;
// Function to insetail new node
static void nodeInsetail(int key)
{
Node p = new Node();
p.info = key;
p.next = null;
// If first node to be insetailed in doubly
// linked list
if (head == null)
{
head = p;
tail = p;
head.prev = null;
return;
}
// If node to be insetailed has value less
// than first node
if (p.info < head.info)
{
p.prev = null;
head.prev = p;
p.next = head;
head = p;
return;
}
// If node to be insetailed has value more
// than last node
if (p.info > tail.info)
{
p.prev = tail;
tail.next = p;
tail = p;
return;
}
// Find the node before which we need to
// insert p.
Node temp = head.next;
while (temp.info < p.info)
temp = temp.next;
// Insert new node before temp
(temp.prev).next = p;
p.prev = temp.prev;
temp.prev = p;
p.next = temp;
}
// Function to print nodes in from left to right
static void printList(Node temp)
{
while (temp != null)
{
System.out.print(temp.info + " ");
temp = temp.next;
}
}
// Driver code
public static void main(String args[])
{
head = tail = null;
nodeInsetail(30);
nodeInsetail(50);
nodeInsetail(90);
nodeInsetail(10);
nodeInsetail(40);
nodeInsetail(110);
nodeInsetail(60);
nodeInsetail(95);
nodeInsetail(23);
System.out.println("Doubly linked list on printing from left to right");
printList(head);
}
}
// This code is contributed by rachana soma
# Python program to insetail nodes in doubly
# linked list such that list remains in
# ascending order on printing from left
# to right
# Linked List node
class Node:
def __init__(self, data):
self.info = data
self.next = None
self.prev = None
head = None
tail = None
# Function to insetail new node
def nodeInsetail( key) :
global head
global tail
p = Node(0)
p.info = key
p.next = None
# If first node to be insetailed in doubly
# linked list
if ((head) == None) :
(head) = p
(tail) = p
(head).prev = None
return
# If node to be insetailed has value less
# than first node
if ((p.info) < ((head).info)) :
p.prev = None
(head).prev = p
p.next = (head)
(head) = p
return
# If node to be insetailed has value more
# than last node
if ((p.info) > ((tail).info)) :
p.prev = (tail)
(tail).next = p
(tail) = p
return
# Find the node before which we need to
# insert p.
temp = (head).next
while ((temp.info) < (p.info)) :
temp = temp.next
# Insert new node before temp
(temp.prev).next = p
p.prev = temp.prev
temp.prev = p
p.next = temp
# Function to print nodes in from left to right
def printList(temp) :
while (temp != None) :
print( temp.info, end = " ")
temp = temp.next
# Driver program to test above functions
nodeInsetail( 30)
nodeInsetail( 50)
nodeInsetail( 90)
nodeInsetail( 10)
nodeInsetail( 40)
nodeInsetail( 110)
nodeInsetail( 60)
nodeInsetail( 95)
nodeInsetail( 23)
print("Doubly linked list on printing from left to right\n" )
printList(head)
# This code is contributed by Arnab Kundu
/* C# program to insetail nodes in doubly
linked list such that list remains in
ascending order on printing from left
to right */
using System;
// A linked list node
public class Node
{
public int info;
public Node prev, next;
}
class GFG
{
static Node head, tail;
// Function to insetail new node
static void nodeInsetail(int key)
{
Node p = new Node();
p.info = key;
p.next = null;
// If first node to be insetailed in doubly
// linked list
if (head == null)
{
head = p;
tail = p;
head.prev = null;
return;
}
// If node to be insetailed has value less
// than first node
if (p.info < head.info)
{
p.prev = null;
head.prev = p;
p.next = head;
head = p;
return;
}
// If node to be insetailed has value more
// than last node
if (p.info > tail.info)
{
p.prev = tail;
tail.next = p;
tail = p;
return;
}
// Find the node before which we need to
// insert p.
Node temp = head.next;
while (temp.info < p.info)
temp = temp.next;
// Insert new node before temp
(temp.prev).next = p;
p.prev = temp.prev;
temp.prev = p;
p.next = temp;
}
// Function to print nodes in from left to right
static void printList(Node temp)
{
while (temp != null)
{
Console.Write(temp.info + " ");
temp = temp.next;
}
}
// Driver code
public static void Main(String []args)
{
head = tail = null;
nodeInsetail(30);
nodeInsetail(50);
nodeInsetail(90);
nodeInsetail(10);
nodeInsetail(40);
nodeInsetail(110);
nodeInsetail(60);
nodeInsetail(95);
nodeInsetail(23);
Console.WriteLine("Doubly linked list on printing from left to right");
printList(head);
}
}
// This code is contributed by Arnab Kundu
<script>
/* javascript program to insetail nodes in doubly
linked list such that list remains in
ascending order on printing from left
to right */
// A linked list node
class Node {
constructor() {
this.info = 0;
this.prev = null;
this.next = null;
}
}
var head, tail;
// Function to insetail new node
function nodeInsetail(key) {
p = new Node();
p.info = key;
p.next = null;
// If first node to be insetailed in doubly
// linked list
if (head == null) {
head = p;
tail = p;
head.prev = null;
return;
}
// If node to be insetailed has value less
// than first node
if (p.info < head.info) {
p.prev = null;
head.prev = p;
p.next = head;
head = p;
return;
}
// If node to be insetailed has value more
// than last node
if (p.info > tail.info) {
p.prev = tail;
tail.next = p;
tail = p;
return;
}
// Find the node before which we need to
// insert p.
temp = head.next;
while (temp.info < p.info)
temp = temp.next;
// Insert new node before temp
(temp.prev).next = p;
p.prev = temp.prev;
temp.prev = p;
p.next = temp;
}
// Function to print nodes in from left to right
function printList( temp) {
while (temp != null) {
document.write(temp.info + " ");
temp = temp.next;
}
}
// Driver code
head = tail = null;
nodeInsetail(30);
nodeInsetail(50);
nodeInsetail(90);
nodeInsetail(10);
nodeInsetail(40);
nodeInsetail(110);
nodeInsetail(60);
nodeInsetail(95);
nodeInsetail(23);
document.write("Doubly linked list on printing from left to right<br/>");
printList(head);
// This code is contributed by aashish1995
</script>
OutputDoubly linked list on printing from left to right
10 23 30 40 50 60 90 95 110
Time complexity: O(n) since using a single loop to traverse doubly linked list
Auxiliary Space: O(1)
Similar Reads
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, 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 = 9Output: 3<->5<->8<->9<-
9 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
Insertion in a sorted circular linked list when a random pointer is given Given an array arr[] of integers and a pointer to a random node of a circular sorted linked list (initially empty), the task is to insert all the elements of arr[] into the circular linked list. Examples: Input: arr[] = {12, 56, 2, 11, 1, 90} Output: 1 2 11 12 56 90 Input: arr[] = {6, 2, 78, 45, 200
12 min read
Insert a Node at a specific position in Doubly Linked List 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 = 3Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node with data = 3 is inserted at posi
13 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 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
Swap given nodes in a Doubly Linked List without modifying data Given a doubly linked list having all unique elements and two keys X and Y, the task is to swap nodes for two given keys by changing links only. Note: It may be considered that X and Y are always present in the list. Examples: Input: list = 1 <-> 8 <-> 7 <-> 9 <-> 4, X = 1, Y
11 min read
How to create a pointer to another pointer in a linked list? In this article we cover how to create a pointer to another pointer in a linked list, it can be singly, doubly, or circularly. What is Linked List: A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked
7 min read
Sort linked list which is already sorted on absolute values Given a linked list that is sorted based on absolute values. Sort the list based on actual values. Examples: Input : 1 -> -10 output: -10 -> 1 Input : 1 -> -2 -> -3 -> 4 -> -5 output: -5 -> -3 -> -2 -> 1 -> 4 Input : -5 -> -10 Output: -10 -> -5 Input : 5 -> 10
9 min read