Facebook Page Twitter Page LinkedIn Page
× Data Structures - Doubly Linked List Other Related Topics


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() {
  if(head != NULL) {
  
    //1. if head is not null create nodes -
    //   evenNode and oddNode
    Node* oddNode = head;
    Node* evenNode = head->next; 
    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) {
  if(*head_ref != NULL) {
  
    //1. if head is not null create nodes -
    //   evenNode and oddNode
    struct Node* oddNode = *head_ref;
    struct Node* evenNode = (*head_ref)->next;
    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):  
  if (self.head != None):
    #1. if head is not null create nodes -
    #   evenNode and oddNode
    oddNode = self.head
    evenNode = self.head.next 

    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() {
  if(this.head != null) {
  
    //1. if head is not null create nodes -
    //   evenNode and oddNode
    Node oddNode = this.head;
    Node evenNode = this.head.next; 
    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() {
  if(this.head != null) {
  
    //1. if head is not null create nodes -
    //   evenNode and oddNode
    Node oddNode = this.head;
    Node evenNode = this.head.next; 
    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() {
  if($this->head != null) {
  
    //1. if head is not null create nodes -
    //   evenNode and oddNode
    $oddNode = $this->head;
    $evenNode = $this->head->next; 
     
    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;
};

class LinkedList {
  private:
    Node* head;
  public:
    LinkedList(){
      head = NULL;
    }
 
    //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; 
      if(head == NULL) {
        head = newNode;
      } else {
        Node* temp = head;
        while(temp->next != NULL)
          temp = temp->next;
        temp->next = newNode;
        newNode->prev = temp;
      }    
    }

    //delete even nodes of the list
    void deleteEvenNodes() {
      if(head != NULL) {
        Node* oddNode = head;
        Node* evenNode = head->next; 
        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() {
      Node* temp = head;
      if(temp != NULL) {
        cout<<"\nThe list contains: ";
        while(temp != NULL) {
          cout<<temp->data<<" ";
          temp = temp->next;
        }
      } else {
        cout<<"\nThe list is empty.";
      }
    }    
};

// test the code 
int main() {
  LinkedList MyList;

  //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<<"\nAfter deleting even nodes.";
  //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;
  if(*head_ref == NULL) {
    *head_ref = newNode;
  } else {
    temp = *head_ref;
    while(temp->next != NULL) {
      temp = temp->next;
    }    
    temp->next = newNode;
    newNode->prev = temp;
  }
}

//delete even nodes of the list
void deleteEvenNodes(struct Node** head_ref) {
  if(*head_ref != NULL) {
    struct Node* oddNode = *head_ref;
    struct Node* evenNode = (*head_ref)->next;
    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
void PrintList(struct Node* head_ref) {
  struct Node* temp = head_ref;
  if(head_ref != NULL) {
    printf("\nThe list contains: ");
    while (temp->next != NULL) {
      printf("%i ",temp->data);
      temp = temp->next;    
    }
    printf("%i ",temp->data);
  } else {
    printf("\nThe list is empty.");
  }   
}   

// 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("\nAfter deleting even nodes.");
  //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

#class Linked List
class LinkedList:
  def __init__(self):
    self.head = None

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

  #delete even nodes of the list
  def deleteEvenNodes(self):  
    if (self.head != None):
      oddNode = self.head
      evenNode = self.head.next 
      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):
    temp = self.head
    if(temp != None):
      print("\nThe list contains:", end=" ")
      while (temp != None):
        print(temp.data, end=" ")
        temp = temp.next
    else:
      print("\nThe list is empty.")

# test the code                  
MyList = LinkedList()

#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("\nAfter 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;
};

class LinkedList {
  Node head;

  LinkedList(){
    head = null;
  }

  //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; 
    if(head == null) {
      head = newNode;
    } else {
      Node temp = new Node();
      temp = head;
      while(temp.next != null)
        temp = temp.next;
      temp.next = newNode;
      newNode.prev = temp;
    }    
  }
  
  //delete even nodes of the list
  void deleteEvenNodes() {
    if(this.head != null) {
      Node oddNode = this.head;
      Node evenNode = this.head.next; 
      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();
    temp = this.head;
    if(temp != null) {
      System.out.print("\nThe list contains: ");
      while(temp != null) {
        System.out.print(temp.data + " ");
        temp = temp.next;
      }
    } else {
      System.out.print("\nThe list is empty.");
    }
  }   
};

// test the code 
public class Implementation {
  public static void main(String[] args) {
    LinkedList MyList = new LinkedList();

    //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.print("\nAfter 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;
};

class LinkedList {
  Node head;

  public LinkedList(){
    head = null;
  }
  
  //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;
    if(head == null) {
      head = newNode;
    } else {
      Node temp = new Node();
      temp = head;
      while(temp.next != null)
        temp = temp.next;
      temp.next = newNode;
      newNode.prev = temp;
    }    
  }

  //delete even nodes of the list
  public void deleteEvenNodes() {
    if(this.head != null) {
      Node oddNode = this.head;
      Node evenNode = this.head.next; 
      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();
    temp = this.head;
    if(temp != null) {
      Console.Write("\nThe list contains: ");
      while(temp != null) {
        Console.Write(temp.data + " ");
        temp = temp.next;
      }
    } else {
      Console.Write("\nThe list is empty.");
    }
  }     
};

// test the code
class Implementation {  
  static void Main(string[] args) {
    LinkedList MyList = new LinkedList();

    //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.Write("\nAfter 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;
}

class LinkedList {
  public $head;

  public function __construct(){
    $this->head = null;
  }
  
  //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; 
    if($this->head == null) {
      $this->head = $newNode;
    } else {
      $temp = new Node();
      $temp = $this->head;
      while($temp->next != null) {
        $temp = $temp->next;
      }
      $temp->next = $newNode;
      $newNode->prev = $temp;
    }    
  }

  //delete even nodes of the list
  public function deleteEvenNodes() {
    if($this->head != null) {
      $oddNode = $this->head;
      $evenNode = $this->head->next;       
      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();
    $temp = $this->head;
    if($temp != null) {
      echo "\nThe list contains: ";
      while($temp != null) {
        echo $temp->data." ";
        $temp = $temp->next;
      }
    } else {
      echo "\nThe list is empty.";
    }
  }   
};

// test the code  
$MyList = new LinkedList();

//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 "\nAfter 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