# Delete initial n nodes in a doubly linked list

Here given code implementation process.

``````//C Program
//Delete initial N nodes 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 {
node->prev = tail;
tail->next = node;

tail = node;

}
}
}
//display element of Node
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 rear
while (temp != NULL) {
//print Node value
printf("%3d", temp->data);
temp = temp->prev;
}
}

}
void delete_front_n(int n)
{
{
return;
}

int counter = 0;
//Check given deleted node are exist or not
while(temp!=NULL && counter < n)
{
counter++;
temp=temp->next;
}

if(counter >= n)
{
counter = n;
{

{
}
if(temp==tail)
{
//when delete all nodes
tail=NULL;
}
free(temp);
temp=NULL;
counter--;
}
}
else
{
printf("\n%d Nodes are not exist in linked list\n",n );
}

}

int main() {

insert(1);
insert(2);
insert(3);
insert(4);
insert(5);
insert(6);
insert(7);
insert(8);

//display all node
display();
int n = 5;
printf("\n\n After Delete Starting %d Nodes\n",n);
delete_front_n(n);

display();
return 0;
}```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````/*
C++ Program
Delete initial N nodes 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";
return;
}
this->tail = node;
} else {
node->prev = this->tail;
this->tail->next = node;
this->tail = 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;
}
}
void delete_front_n(int n) {
return;
}
int counter = 0;
while (temp != NULL && counter < n) {
counter++;
temp = temp->next;
}
if (counter >= n) {
counter = n;
while (counter > 0 && this->head != NULL) {
}
if (temp == this->tail) {
this->tail = NULL;
}
temp = NULL;
counter--;
}
} else {
cout << "\n" << n << " Nodes are not exist in linked list\n";
}
}
};

int main() {
obj.insert(1);
obj.insert(2);
obj.insert(3);
obj.insert(4);
obj.insert(5);
obj.insert(6);
obj.insert(7);
obj.insert(8);
cout << "\nBefore Delete";
obj.display();
int n = 5;
obj.delete_front_n(n);
cout << "\n\n After Delete initial " << n << " Nodes\n";
obj.display();
return 0;
}```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````/*
Java Program
Delete initial N nodes 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");
return;
}
tail = node;
} else {
node.prev = tail;
tail.next = node;
tail = 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 void delete_front_n(int n) {

return;
}
int counter = 0;

while (temp != null && counter < n) {
counter++;
temp = temp.next;
}

if (counter >= n) {
counter = n;

while (counter > 0 && head != null) {

}

if (temp == tail) {
//Delete last node
tail = null;
}

temp = null;
counter--;
}
} else {

System.out.print("\n"+n+" Nodes are not exist in linked list\n");
}
}

public static void main(String[] args) {
obj.insert(1);
obj.insert(2);
obj.insert(3);
obj.insert(4);
obj.insert(5);
obj.insert(6);
obj.insert(7);
obj.insert(8);

System.out.print("\nBefore Delete");
obj.display();

int n = 5;
obj.delete_front_n(n);

System.out.print("\n\n After Delete initial "+n+" Nodes\n");
obj.display();
}

}```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````/*
C# Program
Delete initial N nodes 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");
return;
}
tail = node;
} else {
node.prev = tail;
tail.next = node;
tail = 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 void delete_front_n(int n) {

return;
}
int counter = 0;

while (temp != null && counter < n) {
counter++;
temp = temp.next;
}

if (counter >= n) {
counter = n;

while (counter > 0 && head != null) {

}

if (temp == tail) {
//Delete last node
tail = null;
}

temp = null;
counter--;
}
} else {

Console.Write("\n"+n+" Nodes are not exist in linked list\n");
}
}

public static void Main(String[] args) {
obj.insert(1);
obj.insert(2);
obj.insert(3);
obj.insert(4);
obj.insert(5);
obj.insert(6);
obj.insert(7);
obj.insert(8);

Console.Write("\nBefore Delete");
obj.display();

int n = 5;
obj.delete_front_n(n);

Console.Write("\n\n After Delete initial "+n+" Nodes\n");
obj.display();
}

}```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````# Python 3 Program
# Delete initial N nodes 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")
return

self.tail = node
else :
node.prev = self.tail
self.tail.next = node
self.tail = 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 delete_front_n(self, n) :
return

counter = 0
while (temp != None and counter < n) :
counter += 1
temp = temp.next

if (counter >= n) :
counter = n
while (counter > 0 and self.head != None) :

if (temp == self.tail) :
self.tail = None

temp = None
counter -= 1

else :
print("\n", n ," Nodes are not exist in linked list")

def main() :
obj.insert(1)
obj.insert(2)
obj.insert(3)
obj.insert(4)
obj.insert(5)
obj.insert(6)
obj.insert(7)
obj.insert(8)
print("\nBefore Delete")
obj.display()
n = 5
obj.delete_front_n(n)
print("\n\n After Delete initial ", n ," Nodes")
obj.display()

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

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````# Ruby Program
# Delete initial N nodes 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")
return
end
@tail = node
else
node.prev = @tail
@tail.next = node
@tail = node
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
def delete_front_n(n)
return
end
counter = 0
while (temp != nil and counter < n)
counter += 1
temp = temp.next
end
if (counter >= n)
counter = n
while (counter > 0 and @head != nil)
end
if (temp == @tail)
@tail = nil
end
temp = nil
counter -= 1
end
else
print("\n", n ," Nodes are not exist in linked list\n")
end
end
end

def main()
obj.insert(1)
obj.insert(2)
obj.insert(3)
obj.insert(4)
obj.insert(5)
obj.insert(6)
obj.insert(7)
obj.insert(8)
print("\nBefore Delete")
obj.display()
n = 5
obj.delete_front_n(n)
print("\n\n After Delete initial ", n ," Nodes")
obj.display()
end
main()```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````<?php
/*
Php Program
Delete initial N nodes 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");
return;
}
\$this->tail = \$node;
} else {
\$node->prev = \$this->tail;
\$this->tail->next = \$node;
\$this->tail = \$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;
}
}
public  function delete_front_n(\$n) {
return;
}
\$counter = 0;
while (\$temp != null && \$counter < \$n) {
\$counter++;
\$temp = \$temp->next;
}
if (\$counter >= \$n) {
\$counter = \$n;
while (\$counter > 0 && \$this->head != null) {
}
if (\$temp == \$this->tail) {
\$this->tail = null;
}
\$temp = null;
\$counter--;
}
} else {
echo("\n". \$n ." Nodes are not exist in linked list\n");
}
}
}

function main() {
\$obj->insert(1);
\$obj->insert(2);
\$obj->insert(3);
\$obj->insert(4);
\$obj->insert(5);
\$obj->insert(6);
\$obj->insert(7);
\$obj->insert(8);
echo("\nBefore Delete");
\$obj->display();
\$n = 5;
\$obj->delete_front_n(\$n);
echo("\n\n After Delete initial ". \$n ." Nodes\n");
\$obj->display();
}
main();```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````/*
Node Js Program
Delete initial N nodes 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");
return;
}
this.tail = node;
} else {
node.prev = this.tail;
this.tail.next = node;
this.tail = 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;
}
}
delete_front_n(n) {
return;
}
var counter = 0;
while (temp != null && counter < n) {
counter++;
temp = temp.next;
}
if (counter >= n) {
counter = n;
while (counter > 0 && this.head != null) {
}
if (temp == this.tail) {
this.tail = null;
}
temp = null;
counter--;
}
} else {
process.stdout.write("\n" + n + " Nodes are not exist in linked list\n");
}
}
}

function main() {
obj.insert(1);
obj.insert(2);
obj.insert(3);
obj.insert(4);
obj.insert(5);
obj.insert(6);
obj.insert(7);
obj.insert(8);
process.stdout.write("\nBefore Delete");
obj.display();
var n = 5;
obj.delete_front_n(n);
process.stdout.write("\n\n After Delete initial " + n + " Nodes\n");
obj.display();
}

main();```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8
8  7  6``````
``````/*
Swift 4 Program
Delete initial N nodes 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");
return;
}
self.tail = node;
} else {
node!.prev = self.tail;
self.tail!.next = node;
self.tail = 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 delete_front_n(_ n: Int) {
return;
}
var counter: Int = 0;
while (temp != nil && counter < n) {
counter += 1;
temp = temp!.next;
}
if (counter >= n) {
counter = n;
while (counter > 0 && self.head != nil) {
}
if (temp === self.tail) {
self.tail = nil;
}
temp = nil;
counter -= 1;
}
} else {
print("\n", n ," Nodes are not exist in linked list");
}
}
}
func main() {
obj.insert(1);
obj.insert(2);
obj.insert(3);
obj.insert(4);
obj.insert(5);
obj.insert(6);
obj.insert(7);
obj.insert(8);
print("\nBefore Delete");
obj.display();
let n: Int = 5;
obj.delete_front_n(n);
print("\n\n After Delete initial ", n ," Nodes");
obj.display();
}
main();```
```

#### Output

`````` Head to Tail Nodes :
1  2  3  4  5  6  7  8
8  7  6  5  4  3  2  1

After Delete Starting 5 Nodes

6  7  8