# Doubly Linked List - Delete even nodes

Deleting even nodes of a doubly linked list requires traverse through the list and deleting even nodes one by one. It requires creating two nodes - oddNode and evenNode. If head is not null, make oddNode to first odd node of list and evenNode to first even node of the list. If both are not null, delete the evenNode and adjust links. Move both nodes to next set of odd-even nodes. Repeat the process till any or both nodes become null.

The function deleteEvenNodes is created for this purpose. It is a 4-step process.

```void deleteEvenNodes() {

//1. if head is not null create nodes -
//   evenNode and oddNode
Node* temp = new Node();

while(oddNode != NULL && evenNode != NULL) {

//2. while oddNode and evenNode are not null
//   make next of oddNode as next of evenNode
//   and free evenNode
oddNode->next = evenNode->next;
free(evenNode);

//3. and make temp as oddNode and oddNode as
//   next of oddNode
temp = oddNode;
oddNode = oddNode->next;

//4. Update prev link, oddNode and evenNode
if(oddNode != NULL){
oddNode->prev = temp;
evenNode = oddNode->next;
}
}
}
}
```
```void deleteEvenNodes(struct Node** head_ref) {

//1. if head is not null create nodes -
//   evenNode and oddNode
struct Node* temp;

while(oddNode != NULL && evenNode != NULL) {

//2. while oddNode and evenNode are not null
//   make next of oddNode as next of evenNode
//   and free evenNode
oddNode->next = evenNode->next;
free(evenNode);

//3. and make temp as oddNode and oddNode as
//   next of oddNode
temp = oddNode;
oddNode = oddNode->next;

//4. Update prev link, oddNode and evenNode
if(oddNode != NULL){
oddNode->prev = temp;
evenNode = oddNode->next;
}
}
}
}
```
```def deleteEvenNodes(self):
#1. if head is not null create nodes -
#   evenNode and oddNode

while(oddNode != None and evenNode != None):

#2. while oddNode and evenNode are not null
#   make next of oddNode as next of evenNode
#   and free evenNode
oddNode.next = evenNode.next
evenNode = None

#3. and make temp as oddNode and oddNode as
#   next of oddNode
temp = oddNode
oddNode = oddNode.next

#4. Update prev link, oddNode and evenNode
if(oddNode != None):
oddNode.prev = temp
evenNode = oddNode.next
```
```void deleteEvenNodes() {

//1. if head is not null create nodes -
//   evenNode and oddNode
Node temp = new Node();

while(oddNode != null && evenNode != null) {

//2. while oddNode and evenNode are not null
//   make next of oddNode as next of evenNode
//   and free evenNode
oddNode.next = evenNode.next;
evenNode = null;

//3. and make temp as oddNode and oddNode as
//   next of oddNode
temp = oddNode;
oddNode = oddNode.next;

//4. Update prev link, oddNode and evenNode
if(oddNode != null){
oddNode.prev = temp;
evenNode = oddNode.next;
}
}
}
}
```
```public void deleteEvenNodes() {

//1. if head is not null create nodes -
//   evenNode and oddNode
Node temp = new Node();

while(oddNode != null && evenNode != null) {

//2. while oddNode and evenNode are not null
//   make next of oddNode as next of evenNode
//   and free evenNode
oddNode.next = evenNode.next;
evenNode = null;

//3. and make temp as oddNode and oddNode as
//   next of oddNode
temp = oddNode;
oddNode = oddNode.next;

//4. Update prev link, oddNode and evenNode
if(oddNode != null){
oddNode.prev = temp;
evenNode = oddNode.next;
}
}
}
}
```
```public function deleteEvenNodes() {

//1. if head is not null create nodes -
//   evenNode and oddNode

while(\$oddNode != null && \$evenNode != null) {

//2. while oddNode and evenNode are not null
//   make next of oddNode as next of evenNode
//   and free evenNode
\$oddNode->next = \$evenNode->next;
\$evenNode = null;

//3. and make temp as oddNode and oddNode as
//   next of oddNode
\$temp = \$oddNode;
\$oddNode = \$oddNode->next;

//4. Update prev link, oddNode and evenNode
if(\$oddNode != null){
\$oddNode->prev = \$temp;
\$evenNode = \$oddNode->next;
}
}
}
}
```

The below is a complete program that uses above discussed concept of deleting even nodes of a doubly linked list.

```#include <iostream>
using namespace std;

//node structure
struct Node {
int data;
Node* next;
Node* prev;
};

private:
public:
}

//Add new element at the end of the list
void push_back(int newElement) {
Node* newNode = new Node();
newNode->data = newElement;
newNode->next = NULL;
newNode->prev = NULL;
} else {
while(temp->next != NULL)
temp = temp->next;
temp->next = newNode;
newNode->prev = temp;
}
}

//delete even nodes of the list
void deleteEvenNodes() {
Node* temp = new Node();

while(oddNode != NULL && evenNode != NULL) {
oddNode->next = evenNode->next;
free(evenNode);

temp = oddNode;
oddNode = oddNode->next;
if(oddNode != NULL){
oddNode->prev = temp;
evenNode = oddNode->next;
}
}
}
}

//display the content of the list
void PrintList() {
if(temp != NULL) {
cout<<"The list contains: ";
while(temp != NULL) {
cout<<temp->data<<" ";
temp = temp->next;
}
cout<<"\n";
} else {
cout<<"The list is empty.\n";
}
}
};

// test the code
int main() {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete even nodes of the list
MyList.deleteEvenNodes();

cout<<"After deleting even nodes.\n";
//Display the content of the list.
MyList.PrintList();

return 0;
}
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```
```#include <stdio.h>
#include <stdlib.h>

//node structure
struct Node {
int data;
struct Node* next;
struct Node* prev;
};

//Add new element at the end of the list
void push_back(struct Node** head_ref, int newElement) {
struct Node *newNode, *temp;
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = newElement;
newNode->next = NULL;
newNode->prev = NULL;
} else {
while(temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
newNode->prev = temp;
}
}

//delete even nodes of the list
struct Node* temp;

while(oddNode != NULL && evenNode != NULL) {
oddNode->next = evenNode->next;
free(evenNode);

temp = oddNode;
oddNode = oddNode->next;
if(oddNode != NULL){
oddNode->prev = temp;
evenNode = oddNode->next;
}
}
}
}

//display the content of the list
printf("The list contains: ");
while (temp != NULL) {
printf("%i ",temp->data);
temp = temp->next;
}
printf("\n");
} else {
printf("The list is empty.\n");
}
}

// test the code
int main() {
struct Node* MyList = NULL;

//Add five elements in the list.
push_back(&MyList, 10);
push_back(&MyList, 20);
push_back(&MyList, 30);
push_back(&MyList, 40);
push_back(&MyList, 50);

//Display the content of the list.
PrintList(MyList);

//delete even nodes of the list
deleteEvenNodes(&MyList);

printf("After deleting even nodes.\n");
//Display the content of the list.
PrintList(MyList);

return 0;
}
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```
```# node structure
class Node:
def __init__(self, data):
self.data = data
self.next = None
self.prev = None

def __init__(self):

#Add new element at the end of the list
def push_back(self, newElement):
newNode = Node(newElement)
return
else:
while(temp.next != None):
temp = temp.next
temp.next = newNode
newNode.prev = temp

#delete even nodes of the list
def deleteEvenNodes(self):
while(oddNode != None and evenNode != None):
oddNode.next = evenNode.next
evenNode = None

temp = oddNode
oddNode = oddNode.next
if(oddNode != None):
oddNode.prev = temp
evenNode = oddNode.next

#display the content of the list
def PrintList(self):
if(temp != None):
print("The list contains:", end=" ")
while (temp != None):
print(temp.data, end=" ")
temp = temp.next
print()
else:
print("The list is empty.")

# test the code

#Add five elements in the list.
MyList.push_back(10)
MyList.push_back(20)
MyList.push_back(30)
MyList.push_back(40)
MyList.push_back(50)

#Display the content of the list.
MyList.PrintList()

#delete even nodes of the list
MyList.deleteEvenNodes()

print("After deleting even nodes.")
#Display the content of the list.
MyList.PrintList()
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```
```//node structure
class Node {
int data;
Node next;
Node prev;
};

}

//Add new element at the end of the list
void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
newNode.prev = null;
} else {
Node temp = new Node();
while(temp.next != null)
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//delete even nodes of the list
void deleteEvenNodes() {
Node temp = new Node();
while(oddNode != null && evenNode != null) {
oddNode.next = evenNode.next;
evenNode = null;

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

//display the content of the list
void PrintList() {
Node temp = new Node();
if(temp != null) {
System.out.print("The list contains: ");
while(temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
System.out.println();
} else {
System.out.println("The list is empty.");
}
}
};

// test the code
public class Implementation {
public static void main(String[] args) {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete even nodes of the list
MyList.deleteEvenNodes();

System.out.println("After deleting even nodes.");
//Display the content of the list.
MyList.PrintList();
}
}
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```
```using System;

//node structure
class Node {
public int data;
public Node next;
public Node prev;
};

}

//Add new element at the end of the list
public void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
newNode.prev = null;
} else {
Node temp = new Node();
while(temp.next != null)
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//delete even nodes of the list
public void deleteEvenNodes() {
Node temp = new Node();
while(oddNode != null && evenNode != null) {
oddNode.next = evenNode.next;
evenNode = null;

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

//display the content of the list
public void PrintList() {
Node temp = new Node();
if(temp != null) {
Console.Write("The list contains: ");
while(temp != null) {
Console.Write(temp.data + " ");
temp = temp.next;
}
Console.WriteLine();
} else {
Console.WriteLine("The list is empty.");
}
}
};

// test the code
class Implementation {
static void Main(string[] args) {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete even nodes of the list
MyList.deleteEvenNodes();

Console.WriteLine("After deleting even nodes.");
//Display the content of the list.
MyList.PrintList();
}
}
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```
```<?php
//node structure
class Node {
public \$data;
public \$next;
public \$prev;
}

public function __construct(){
}

//Add new element at the end of the list
public function push_back(\$newElement) {
\$newNode = new Node();
\$newNode->data = \$newElement;
\$newNode->next = null;
\$newNode->prev = null;
} else {
\$temp = new Node();
while(\$temp->next != null) {
\$temp = \$temp->next;
}
\$temp->next = \$newNode;
\$newNode->prev = \$temp;
}
}

//delete even nodes of the list
public function deleteEvenNodes() {
while(\$oddNode != null && \$evenNode != null) {
\$oddNode->next = \$evenNode->next;
\$evenNode = null;

\$temp = \$oddNode;
\$oddNode = \$oddNode->next;
if(\$oddNode != null){
\$oddNode->prev = \$temp;
\$evenNode = \$oddNode->next;
}
}
}
}

//display the content of the list
public function PrintList() {
\$temp = new Node();
if(\$temp != null) {
echo "The list contains: ";
while(\$temp != null) {
echo \$temp->data." ";
\$temp = \$temp->next;
}
echo "\n";
} else {
echo "The list is empty.\n";
}
}
};

// test the code

//Add five elements in the list.
\$MyList->push_back(10);
\$MyList->push_back(20);
\$MyList->push_back(30);
\$MyList->push_back(40);
\$MyList->push_back(50);

//Display the content of the list.
\$MyList->PrintList();

//delete even nodes of the list
\$MyList->deleteEvenNodes();

echo "After deleting even nodes.\n";
//Display the content of the list.
\$MyList->PrintList();
?>
```

The above code will give the following output:

```The list contains: 10 20 30 40 50
After deleting even nodes.
The list contains: 10 30 50
```

5