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


Deleting odd nodes of a circular doubly linked list requires traverse through the list and deleting odd nodes one by one. It involves the following process. If the list contains only head then make the head null. If the list contains more than one element then delete the head and adjust the link of last element with the new head. If next of head is not head then, create three nodes - evenNode pointing to head, oddNode pointing to next of head and temp to store last even node. Then delete oddNode and update evenNode and oddNode to next set of odd-even nodes and continue the process till any of the node reaches head. After that if evenNode reaches head, make next of temp as head else make next of evenNode as head and adjust other links accordingly.

The function deleteOddNodes is created for this purpose. It is a 5-step process.

void deleteOddNodes() {
  //1. if head is the only element element in 
  //   list make the head as null  
  if(this.head != null && this.head.next == this.head) {
    this.head = null;
  } else if(this.head != null) {

    //2. if the list contains more than one element
    //   delete the head and adjust the link of
    //   last element with the new head       
    Node temp = this.head;
    while(temp.next != this.head) {
      temp = temp.next;
    }
    temp.next = head.next;
    head.next.prev = temp;
    this.head = null;
    this.head = temp.next;

    //3. create evenNode node - pointing to head
    //   oddNode node - pointing to next of head
    //   temp node - to store last even node
    if(this.head != null && this.head.next != this.head) {

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

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

//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 odd nodes of the list
  void deleteOddNodes() {
    if(this.head != null && this.head.next == this.head) {
      this.head = null;
    } else if(this.head != null) {

      Node temp = this.head;
      while(temp.next != this.head) {
        temp = temp.next;
      }
      temp.next = head.next;
      head.next.prev = temp;
      this.head = null;
      this.head = temp.next;

      if(this.head != null && this.head.next != this.head) {

        Node evenNode = this.head;
        Node oddNode = this.head.next; 
        while(true) {
          temp = evenNode;
          evenNode.next = oddNode.next;
          evenNode.next.prev = evenNode;
          oddNode = null;
          evenNode = evenNode.next;
          oddNode = evenNode.next;
          if(evenNode == this.head || oddNode == this.head)
            break;
        }
        
        if(evenNode == this.head) {
          temp.next = this.head;
          this.head.prev = temp;
        } else {
          evenNode.next = this.head;
          this.head.prev = evenNode;
        }
      }
    } 
  }

  //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(true) {
        System.out.print(temp.data + " ");
        temp = temp.next;
        if(temp == this.head)
          break;
      }
    } 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 odd nodes of the list
    MyList.deleteOddNodes();
 
    System.out.print("\nAfter deleting odd 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 odd nodes:
The list contains: 20 40