Data Structures - Circular Doubly Linked List Other Related Topics
Data Structures - Circular Doubly Linked List Other Related Topics

Circular Doubly Linked List - Delete even nodes

Deleting even nodes of a circular doubly linked list requires traverse through the list and deleting even nodes one by one. It requires creating two nodes - oddNode and evenNode. If the list contains more than one node, make oddNode to first odd node of list and evenNode to first even node of the list. Store the current odd node into temp node and delete the even node. Move both nodes to next set of odd-even nodes. Repeat the process till any of nodes reaches head. Finally, link the last node with the head.

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

void deleteEvenNodes() {
  if(head != NULL && head->next != head) {
  
    //1. if the list has more than one element
    //   create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last odd node
    Node* oddNode = head;
    Node* evenNode = head->next; 
    Node* temp = new Node();

    while(true) {
      
      //2. delete even node and update evenNode and 
      //   oddNode to next set of odd-even nodes
      //   update temp node to latest oddNode node
      //   continue the process till any of the node 
      //   reaches head
      temp = oddNode;
      oddNode->next = evenNode->next;
      oddNode->next->prev = oddNode;
      free(evenNode);
      oddNode = oddNode->next;
      evenNode = oddNode->next;
      if(oddNode == head || evenNode == head)
        break;
    }
    
    //3. if oddNode reaches head, make next of 
    //   temp as head else make next of oddNode
    //   as head
    if(oddNode == head) {
      temp->next = head;
      head->prev = temp;
    } else {
      oddNode->next = head;
      head->prev = oddNode;
    }
  }
} 

void deleteEvenNodes(struct Node** head_ref) {
  if(*head_ref != NULL && (*head_ref)->next != *head_ref) {
  
    //1. if the list has more than one element
    //   create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last odd node
    struct Node* oddNode = *head_ref;
    struct Node* evenNode = (*head_ref)->next;
    struct Node* temp; 

    while(1) {
      
      //2. delete even node and update evenNode and 
      //   oddNode to next set of odd-even nodes
      //   update temp node to latest oddNode node
      //   continue the process till any of the node 
      //   reaches head
      temp = oddNode;
      oddNode->next = evenNode->next;
      oddNode->next->prev = oddNode;
      free(evenNode);
      oddNode = oddNode->next;
      evenNode = oddNode->next;
      if(oddNode == *head_ref || evenNode == *head_ref)
        break;
    }
    
    //3. if oddNode reaches head, make next of 
    //   temp as head else make next of oddNode
    //   as head
    if(oddNode == *head_ref) {
      temp->next = *head_ref;
      (*head_ref)->prev = temp;
    } else {
      oddNode->next = *head_ref;
      (*head_ref)->prev = oddNode;
    }
  }
} 

def deleteEvenNodes(self):  
  if (self.head != None and self.head.next != self.head):
    #1. if the list has more than one element
    #   create evenNode node - pointing to head
    #   oddNode node - pointing to next of head
    #   temp node - to store last odd node
    oddNode = self.head
    evenNode = self.head.next 

    while(True):
      
      #2. delete even node and update evenNode and 
      #   oddNode to next set of odd-even nodes
      #   update temp node to latest oddNode node
      #   continue the process till any of the node 
      #   reaches head  
      temp = oddNode
      oddNode.next = evenNode.next
      oddNode.next.prev = oddNode
      evenNode = None
      oddNode = oddNode.next
      evenNode = oddNode.next
      if(oddNode == self.head or evenNode == self.head):
        break

    #3. if oddNode reaches head, make next of 
    #   temp as head else make next of oddNode
    #   as head
    if(oddNode == self.head):
      temp.next = self.head
      self.head.prev = temp
    else:
      oddNode.next = self.head
      self.head.prev = oddNode

void deleteEvenNodes() {
  if(this.head != null && this.head.next != this.head) {
  
    //1. if the list has more than one element
    //   create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last odd node
    Node oddNode = this.head;
    Node evenNode = this.head.next; 
    Node temp = new Node();

    while(true) {
      
      //2. delete even node and update evenNode and 
      //   oddNode to next set of odd-even nodes
      //   update temp node to latest oddNode node
      //   continue the process till any of the node 
      //   reaches head
      temp = oddNode;
      oddNode.next = evenNode.next;
      oddNode.next.prev = oddNode;
      evenNode = null;
      oddNode = oddNode.next;
      evenNode = oddNode.next;
      if(oddNode == this.head || evenNode == this.head)
        break;
    }
    
    //3. if oddNode reaches head, make next of 
    //   temp as head else make next of oddNode
    //   as head
    if(oddNode == this.head) {
      temp.next = this.head;
      this.head.prev = temp;
    } else {
      oddNode.next = this.head;
      this.head.prev = oddNode;
    }
  }
}    

public void deleteEvenNodes() {
  if(this.head != null && this.head.next != this.head) {
  
    //1. if the list has more than one element
    //   create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last odd node
    Node oddNode = this.head;
    Node evenNode = this.head.next; 
    Node temp = new Node();

    while(true) {
      
      //2. delete even node and update evenNode and 
      //   oddNode to next set of odd-even nodes
      //   update temp node to latest oddNode node
      //   continue the process till any of the node 
      //   reaches head
      temp = oddNode;
      oddNode.next = evenNode.next;
      oddNode.next.prev = oddNode;
      evenNode = null;
      oddNode = oddNode.next;
      evenNode = oddNode.next;
      if(oddNode == this.head || evenNode == this.head)
        break;
    }
    
    //3. if oddNode reaches head, make next of 
    //   temp as head else make next of oddNode
    //   as head
    if(oddNode == this.head) {
      temp.next = this.head;
      this.head.prev = temp;
    } else {
      oddNode.next = this.head;
      this.head.prev = oddNode;
    }
  }
}     

public function deleteEvenNodes() {
  if($this->head != null && $this->head->next != $this->head) {
  
    //1. if the list has more than one element
    //   create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last odd node
    $oddNode = $this->head;
    $evenNode = $this->head->next; 
    $temp = new Node();

    while(true) {
      
      //2. delete even node and update evenNode and 
      //   oddNode to next set of odd-even nodes
      //   update temp node to latest oddNode node
      //   continue the process till any of the node 
      //   reaches head
      $temp = $oddNode;
      $oddNode->next = $evenNode->next;
      $oddNode->next->prev = $oddNode;
      $evenNode = null;
      $oddNode = $oddNode->next;
      $evenNode = $oddNode->next;
      if($oddNode == $this->head || $evenNode == $this->head)
        break;
    }
    
    //3. if oddNode reaches head, make next of 
    //   temp as head else make next of oddNode
    //   as head
    if($oddNode == $this->head) {
      $temp->next = $this->head;
      $this->head->prev = $temp;
    } else {
      $oddNode->next = $this->head;
      $this->head->prev = $oddNode;
    }
  }
}

The below is a complete program that uses above discussed concept of deleting even nodes of a circular 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;
        newNode->next = head;
        newNode->prev = head;
      } else {
        Node* temp = head;
        while(temp->next != head)
          temp = temp->next;
        temp->next = newNode;
        newNode->next = head;
        newNode->prev = temp;
        head->prev = newNode;
      }    
    }
    
    //delete even nodes of the list
    void deleteEvenNodes() {
      if(head != NULL && head->next != head) {
        Node* oddNode = head;
        Node* evenNode = head->next; 
        Node* temp = new Node();
        while(true) {
          temp = oddNode;
          oddNode->next = evenNode->next;
          oddNode->next->prev = oddNode;
          free(evenNode);
          oddNode = oddNode->next;
          evenNode = oddNode->next;
          if(oddNode == head || evenNode == head)
            break;
        }
        if(oddNode == head) {
          temp->next = head;
          head->prev = temp;
        } else {
          oddNode->next = head;
          head->prev = oddNode;
        }
      }
    } 

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

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

//delete even nodes of the list
void deleteEvenNodes(struct Node** head_ref) {
  if(*head_ref != NULL && (*head_ref)->next != *head_ref) {
    struct Node* oddNode = *head_ref;
    struct Node* evenNode = (*head_ref)->next;
    struct Node* temp; 
    while(1) {
      temp = oddNode;
      oddNode->next = evenNode->next;
      oddNode->next->prev = oddNode;
      free(evenNode);
      oddNode = oddNode->next;
      evenNode = oddNode->next;
      if(oddNode == *head_ref || evenNode == *head_ref)
        break;
    }
    if(oddNode == *head_ref) {
      temp->next = *head_ref;
      (*head_ref)->prev = temp;
    } else {
      oddNode->next = *head_ref;
      (*head_ref)->prev = oddNode;
    }
  }
} 

//display the content of the list
void PrintList(struct Node* head_ref) {
  struct Node* temp = head_ref;
  if(head_ref != NULL) {
    printf("The list contains: ");
    while (1) {
      printf("%i ",temp->data);
      temp = temp->next;
      if(temp == head_ref)
        break;    
    }
    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

#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
      newNode.next = self.head
      newNode.prev = self.head
      return
    else:
      temp = self.head
      while(temp.next != self.head):
        temp = temp.next
      temp.next = newNode
      newNode.next = self.head
      newNode.prev = temp
      self.head.prev = newNode

  #delete even nodes of the list
  def deleteEvenNodes(self):  
    if (self.head != None and self.head.next != self.head):
      oddNode = self.head
      evenNode = self.head.next 
      while(True):
        temp = oddNode
        oddNode.next = evenNode.next
        oddNode.next.prev = oddNode
        evenNode = None
        oddNode = oddNode.next
        evenNode = oddNode.next
        if(oddNode == self.head or evenNode == self.head):
          break
      if(oddNode == self.head):
        temp.next = self.head
        self.head.prev = temp
      else:
        oddNode.next = self.head
        self.head.prev = oddNode

  #display the content of the list
  def PrintList(self):
    temp = self.head
    if(temp != None):
      print("The list contains:", end=" ")
      while (True):
        print(temp.data, end=" ")
        temp = temp.next
        if(temp == self.head):
          break
      print()
    else:
      print("The 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("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;
};

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

  //delete even nodes of the list
  void deleteEvenNodes() {
    if(this.head != null && this.head.next != this.head) {
      Node oddNode = this.head;
      Node evenNode = this.head.next; 
      Node temp = new Node();
      while(true) {
        temp = oddNode;
        oddNode.next = evenNode.next;
        oddNode.next.prev = oddNode;
        evenNode = null;
        oddNode = oddNode.next;
        evenNode = oddNode.next;
        if(oddNode == this.head || evenNode == this.head)
          break;
      }
      if(oddNode == this.head) {
        temp.next = this.head;
        this.head.prev = temp;
      } else {
        oddNode.next = this.head;
        this.head.prev = oddNode;
      }
    }
  } 

  //display the content of the list
  void PrintList() {
    Node temp = new Node();
    temp = this.head;
    if(temp != null) {
      System.out.print("The list contains: ");
      while(true) {
        System.out.print(temp.data + " ");
        temp = temp.next;
        if(temp == this.head)
          break;
      }
      System.out.println();
    } else {
      System.out.println("The 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.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;
};

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

  //delete even nodes of the list
  public void deleteEvenNodes() {
    if(this.head != null && this.head.next != this.head) {
      Node oddNode = this.head;
      Node evenNode = this.head.next; 
      Node temp = new Node();
      while(true) {
        temp = oddNode;
        oddNode.next = evenNode.next;
        oddNode.next.prev = oddNode;
        evenNode = null;
        oddNode = oddNode.next;
        evenNode = oddNode.next;
        if(oddNode == this.head || evenNode == this.head)
          break;
      }
      if(oddNode == this.head) {
        temp.next = this.head;
        this.head.prev = temp;
      } else {
        oddNode.next = this.head;
        this.head.prev = oddNode;
      }
    }
  } 

  //display the content of the list
  public void PrintList() {
    Node temp = new Node();
    temp = this.head;
    if(temp != null) {
      Console.Write("The list contains: ");
      while(true) {
        Console.Write(temp.data + " ");
        temp = temp.next;
        if(temp == this.head)
          break;        
      }
      Console.WriteLine();
    } else {
      Console.WriteLine("The 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.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;
}

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

  //delete even nodes of the list
  public function deleteEvenNodes() {
    if($this->head != null && $this->head->next != $this->head) {
      $oddNode = $this->head;
      $evenNode = $this->head->next; 
      $temp = new Node();
      while(true) {
        $temp = $oddNode;
        $oddNode->next = $evenNode->next;
        $oddNode->next->prev = $oddNode;
        $evenNode = null;
        $oddNode = $oddNode->next;
        $evenNode = $oddNode->next;
        if($oddNode == $this->head || $evenNode == $this->head)
          break;
      }
      if($oddNode == $this->head) {
        $temp->next = $this->head;
        $this->head->prev = $temp;
      } else {
        $oddNode->next = $this->head;
        $this->head->prev = $oddNode;
      }
    }
  } 

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

// 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 "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
AlphaCodingSkills
AlphaCodingSkills Android App
Facebook Page Twitter Page LinkedIn Page
Learning Tutorials
Learning Tutorials
Useful Links
Python Libraries
About Us  |  Privacy Policy  |  Contact Us
AlphaCodingSkills is a online learning portal that provides tutorials on Python, Java, C++, C, C#, PHP, R, Ruby, Rust, Scala, Swift, Perl, SQL, Data Structures and Algorithms. Tutorials, examples, references and content of the website are reviewed and simplified continuously to improve comprehensibility and eliminate any possible error. We use cookies to ensure best browsing experience on our website. While using this website, you acknowledge to have read and accepted our cookie and privacy policy.