Sorted insertion in doubly linked list

Here given code implementation process.

``````//C Program
//Sorted insertion in doubly linked list
#include <stdio.h>
#include <stdlib.h> //for malloc function

//create structure
struct Node
{
int data;
struct Node*next;
struct Node*prev;
};
struct Node *head = NULL, *tail = NULL;

//insert Node element of end of linked list
void insert(int value)
{

//Create a dynamic node
struct Node*node=(struct Node*)malloc(sizeof(struct Node));
if(node==NULL)
{
printf("Memory overflow\n");
}else
{
//set data value
node->data=value;
node->next=NULL;
node->prev=NULL;
{
tail=node;

}
{

}
else if(tail->data<=value)
{
tail->next = node;
node->prev = tail;

tail = node;
}
else
{
//find last node
while(temp!=NULL && temp->next!=NULL && temp->next->data < value)
{
temp=temp->next;
}
//add new node to last positions
node->next = temp->next;
if(temp->next!=NULL)
{
temp->next->prev=node;
}
node->prev = temp;
temp->next = node;
}
}
}
//display element of Nodes
void display() {
if (temp == NULL) {
} else {

printf("\n Head to Tail Nodes : \n");
//Traverse doubly linked list from front to rear
while (temp != NULL) {
//print Node value
printf("%3d", temp->data);
temp = temp->next;
}

printf("\n Tail to Head Nodes : \n");

temp = tail;

//Traverse doubly linked list from rear to front
while (temp != NULL) {
//print Node value
printf("%3d", temp->data);
temp = temp->prev;
}
}

}
int main(){

insert(3);
insert(5);
insert(7);
insert(12);
insert(10);
insert(6);
insert(4);
insert(1);
insert(-1);
//Display all
display();
return 0;
}```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7 10 12
12 10  7  6  5  4  3  1 -1``````
``````/*
C++ Program
Sorted insertion in doubly linked list
*/

#include<iostream>

using namespace std;
class Node {
public:
int data;
Node *next;
Node *prev;
Node(int value) {
this->data = value;
this->next = NULL;
this->prev = NULL;
}
};
public:
Node *tail;
this->tail = NULL;
}
void insert(int value) {
Node *node = new Node(value);
if (node == NULL) {
cout << "Memory overflow\n";
} else {
this->tail = node;
} else
} else
if (this->tail->data <= value) {
this->tail->next = node;
this->tail = node;
} else {
while (temp != NULL && temp->next != NULL && temp->next->data < value) {
temp = temp->next;
}
node->next = temp->next;
if (temp->next != NULL) {
temp->next->prev = node;
}
node->prev = temp;
temp->next = node;
}
}
}
void display() {
if (temp == NULL) {
return;
}
cout << "\n Head to Tail Nodes : \n";
while (temp != NULL) {
cout << temp->data << "  ";
temp = temp->next;
}
temp = this->tail;
cout << "\n Tail to Head Nodes : \n";
while (temp != NULL) {
cout << temp->data << "  ";
temp = temp->prev;
}
}

};
int main() {
obj.insert(3);
obj.insert(5);
obj.insert(7);
obj.insert(12);
obj.insert(10);
obj.insert(6);
obj.insert(4);
obj.insert(1);
obj.insert(-1);
obj.display();
return 0;
}```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````/*
Java Program
Sorted insertion in doubly linked list

*/
class Node {

public int data;

public Node next;

public Node prev;

public Node(int value) {
//Setup initial values of linked list node
this.data = value;
this.next = null;
this.prev = null;
}
}

public Node tail;

{
tail = null;
}
public void insert(int value) {

Node node = new Node(value);

if (node == null) {
System.out.print("Memory overflow\n");
}
else {

tail = node;
}
else if (head.data >= value) {
}
else if(tail.data <= value)
{
tail.next = node;
tail = node;
}
else {

while (temp != null && temp.next != null && temp.next.data < value) {
temp = temp.next;
}
node.next = temp.next;

if (temp.next != null) {
temp.next.prev = node;
}

node.prev = temp;
temp.next = node;

}
}
}
public void display() {
if (temp == null) {
return;
}

System.out.print("\n Head to Tail Nodes : \n");

while (temp != null) {
System.out.print(temp.data+"  ");
temp = temp.next;
}

temp = tail;

System.out.print("\n Tail to Head Nodes : \n");

while (temp != null) {
System.out.print(temp.data+"  ");
temp = temp.prev;
}

}
public static void main(String[] args) {
obj.insert(3);
obj.insert(5);
obj.insert(7);
obj.insert(12);
obj.insert(10);
obj.insert( 6);
obj.insert(4);
obj.insert(1);
obj.insert(-1);
obj.display();

}

}```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````/*
C# Program
Sorted insertion in doubly linked list

*/

using System;
public class Node {

public int data;

public Node next;

public Node prev;

public Node(int value) {
//Setup initial values of linked list node
this.data = value;
this.next = null;
this.prev = null;
}
}

public Node tail;

{
tail = null;
}
public void insert(int value) {

Node node = new Node(value);

if (node == null) {
Console.Write("Memory overflow\n");
}
else {

tail = node;
}
else if (head.data >= value) {
}
else if(tail.data <= value)
{
tail.next = node;
tail = node;
}
else {

while (temp != null && temp.next != null && temp.next.data < value) {
temp = temp.next;
}
node.next = temp.next;

if (temp.next != null) {
temp.next.prev = node;
}

node.prev = temp;
temp.next = node;

}
}
}
public void display() {
if (temp == null) {
return;
}

Console.Write("\n Head to Tail Nodes : \n");

while (temp != null) {
Console.Write(temp.data+"  ");
temp = temp.next;
}

temp = tail;

Console.Write("\n Tail to Head Nodes : \n");

while (temp != null) {
Console.Write(temp.data+"  ");
temp = temp.prev;
}

}
public static void Main(String[] args) {
obj.insert(3);
obj.insert(5);
obj.insert(7);
obj.insert(12);
obj.insert(10);
obj.insert( 6);
obj.insert(4);
obj.insert(1);
obj.insert(-1);
obj.display();

}

}```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````# Python 3 Program
# Sorted insertion in doubly linked list

class Node :

def __init__(self, value) :
self.data = value
self.next = None
self.prev = None

def __init__(self) :
self.tail = None

def insert(self, value) :
node = Node(value)
if (node == None) :
print("Memory overflow\n")
else :
self.tail = node
elif (self.tail.data <= value) :
self.tail.next = node
self.tail = node
else :
while (temp != None and temp.next != None and temp.next.data < value) :
temp = temp.next

node.next = temp.next
if (temp.next != None) :
temp.next.prev = node

node.prev = temp
temp.next = node

def display(self) :
if (temp == None) :
return

print("\n Head to Tail Nodes : ")
while (temp != None) :
print(temp.data ,end="  ")
temp = temp.next

temp = self.tail
print("\n Tail to Head Nodes : ")
while (temp != None) :
print(temp.data ,end="  ")
temp = temp.prev

def main() :
obj.insert(3)
obj.insert(5)
obj.insert(7)
obj.insert(12)
obj.insert(10)
obj.insert(6)
obj.insert(4)
obj.insert(1)
obj.insert(-1)
obj.display()

if __name__ == "__main__":
main()```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````# Ruby Program
#  Sorted insertion in doubly linked list

class Node
attr_accessor :data, :next, :prev
def initialize(value)
self.data = value
self.next = nil
self.prev = nil
end
end

def initialize()
@tail = nil
end
def insert(value)
node = Node.new(value)
if (node == nil)
print("Memory overflow\n")
else
@tail = node
elsif (@tail.data <= value)
@tail.next = node
@tail = node
else
while (temp != nil and temp.next != nil and temp.next.data < value)
temp = temp.next
end
node.next = temp.next
if (temp.next != nil)
temp.next.prev = node
end
node.prev = temp
temp.next = node
end
end
end
def display()
if (temp == nil)
return
end
print("\n Head to Tail Nodes  :\n")
while (temp != nil)
print(temp.data ,"  ")
temp = temp.next
end
temp = @tail
print("\n Tail to Head Nodes  :\n")
while (temp != nil)
print(temp.data ,"  ")
temp = temp.prev
end
end
end

def main()
obj.insert(3)
obj.insert(5)
obj.insert(7)
obj.insert(12)
obj.insert(10)
obj.insert(6)
obj.insert(4)
obj.insert(1)
obj.insert(-1)
obj.display()
end

main()```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````<?php
/*
Php Program
Sorted insertion in doubly linked list
*/

class Node {
public \$data;
public \$next;
public \$prev;

function __construct(\$value) {
\$this->data = \$value;
\$this->next = null;
\$this->prev = null;
}
}
public \$tail;

function __construct() {
\$this->tail = null;
}
public  function insert(\$value) {
\$node = new Node(\$value);
if (\$node == null) {
echo("Memory overflow\n");
} else {
\$this->tail = \$node;
} else
} else
if (\$this->tail->data <= \$value) {
\$this->tail->next = \$node;
\$this->tail = \$node;
} else {
while (\$temp != null && \$temp->next != null && \$temp->next->data < \$value) {
\$temp = \$temp->next;
}
\$node->next = \$temp->next;
if (\$temp->next != null) {
\$temp->next->prev = \$node;
}
\$node->prev = \$temp;
\$temp->next = \$node;
}
}
}
public  function display() {
if (\$temp == null) {
return;
}
echo("\n Head to Tail Nodes : \n");
while (\$temp != null) {
echo(\$temp->data ."  ");
\$temp = \$temp->next;
}
\$temp = \$this->tail;
echo("\n Tail to Head Nodes : \n");
while (\$temp != null) {
echo(\$temp->data ."  ");
\$temp = \$temp->prev;
}
}

}
function main() {
\$obj->insert(3);
\$obj->insert(5);
\$obj->insert(7);
\$obj->insert(12);
\$obj->insert(10);
\$obj->insert(6);
\$obj->insert(4);
\$obj->insert(1);
\$obj->insert(-1);
\$obj->display();
}
main();```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````/*
Node Js Program
Sorted insertion in doubly linked list
*/

class Node {

constructor(value) {
this.data = value;
this.next = null;
this.prev = null;
}
}

constructor() {
this.tail = null;
}
insert(value) {
var node = new Node(value);
if (node == null) {
process.stdout.write("Memory overflow\n");
} else {
this.tail = node;
} else
} else
if (this.tail.data <= value) {
this.tail.next = node;
this.tail = node;
} else {
while (temp != null && temp.next != null && temp.next.data < value) {
temp = temp.next;
}
node.next = temp.next;
if (temp.next != null) {
temp.next.prev = node;
}
node.prev = temp;
temp.next = node;
}
}
}
display() {
if (temp == null) {
return;
}
process.stdout.write("\n Head to Tail Nodes : \n");
while (temp != null) {
process.stdout.write(temp.data + "  ");
temp = temp.next;
}
temp = this.tail;
process.stdout.write("\n Tail to Head Nodes : \n");
while (temp != null) {
process.stdout.write(temp.data + "  ");
temp = temp.prev;
}
}
}

function main() {
obj.insert(3);
obj.insert(5);
obj.insert(7);
obj.insert(12);
obj.insert(10);
obj.insert(6);
obj.insert(4);
obj.insert(1);
obj.insert(-1);
obj.display();
}

main();```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12
12  10  7  6  5  4  3  1  -1 ``````
``````/*
Swift 4 Program
Sorted insertion in doubly linked list
*/

class Node {
var data: Int;
var next: Node? ;
var prev: Node? ;
init(_ value: Int) {
self.data = value;
self.next = nil;
self.prev = nil;
}
}
var tail: Node? ;
init() {
self.tail = nil;
}
func insert(_ value: Int) {
let node: Node? = Node(value);
if (node == nil) {
print("Memory overflow\n");
} else {
self.tail = node;
} else
} else
if (self.tail!.data <= value) {
self.tail!.next = node;
self.tail = node;
} else {
while (temp != nil && temp!.next != nil && temp!.next!.data < value) {
temp = temp!.next;
}
node!.next = temp!.next;
if (temp!.next != nil) {
temp!.next!.prev = node;
}
node!.prev = temp;
temp!.next = node;
}
}
}
func display() {
if (temp == nil) {
return;
}
print("\n Head to Tail Nodes : ");
while (temp != nil) {
print(temp!.data ,terminator:"  ");
temp = temp!.next;
}
temp = self.tail;
print("\n Tail to Head Nodes : ");
while (temp != nil) {
print(temp!.data ,terminator:"  ");
temp = temp!.prev;
}
}
}

func main() {
obj.insert(3);
obj.insert(5);
obj.insert(7);
obj.insert(12);
obj.insert(10);
obj.insert(6);
obj.insert(4);
obj.insert(1);
obj.insert(-1);
obj.display();
}
main();```
```

Output

`````` Head to Tail Nodes :
-1  1  3  4  5  6  7  10  12