Remove all even parity nodes from a Doubly and Circular Singly Linked List

/*package whatever //do not write package name here */

import java.io.*;
public class GFG {
  static Node head; // head of linked list

  // Node of the doubly linked list
  class Node {
    int data;
    Node prev;
    Node next;
    // Constructor to create a new node
    // next and prev is by default initialized as null
    Node(int d) { data = d; }
  }

  // Add a node at the end of the list
  public void append(int new_data)
  {
    /* 1. allocate node
         * 2. put in the data */
    Node new_node = new Node(new_data);

    Node last = head; /* used in step 5*/

    /* 3. This new node is going to be the last node, so
         * make next of it as NULL*/
    new_node.next = null;

    /* 4. If the Linked List is empty, then make the new
         * node as head */
    if (head == null) {
      new_node.prev = null;
      head = new_node;
      return;
    }

    /* 5. Else traverse till the last node */
    while (last.next != null)
      last = last.next;

    /* 6. Change the next of last node */
    last.next = new_node;

    /* 7. Make last node as previous of new node */
    new_node.prev = last;
  }

  // Function to delete a node in a Doubly Linked List.
  // head_ref --> pointer to head node pointer.
  // del --> data of node to be deleted.
  public static void deleteNode(Node del)
  {

    // Base case
    if (head == null || del == null) {
      return;
    }

    // If node to be deleted is head node
    if (head == del) {
      head = del.next;
    }

    // Change next only if node to be deleted
    // is NOT the last node
    if (del.next != null) {
      del.next.prev = del.prev;
    }

    // Change prev only if node to be deleted
    // is NOT the first node
    if (del.prev != null) {
      del.prev.next = del.next;
    }

    // Finally, free the memory occupied by del
    return;
  }
  // Function that returns true if count
  // of set bits in x is even
  public static boolean isEvenParity(int x)
  {
    // parity will store the
    // count of set bits
    int parity = 0;
    while (x != 0) {
      if (x % 2 == 1)
        parity++;
      x = x >> 1;
    }

    if (parity % 2 == 0)
      return true;
    else
      return false;
  }
  // Function to to remove all
  // the Even Parity Nodes from a
  // doubly linked list
  public static void deleteEvenParityNodes()
  {
    Node ptr = head;
    Node next;

    // Iterating through
    // the linked list
    while (ptr != null) {
      next = ptr.next;

      // If node's data's parity
      // is even
      if (isEvenParity(ptr.data)) {
        deleteNode(ptr);
      }
      ptr = next;
    }
  }
  // This function prints contents of
  // linked list starting from the given node
  public static void printlist()
  {
    Node node = head;
    System.out.println(
      "Traversal in forward Direction");
    while (node != null) {
      System.out.print(node.data + " ");
      node = node.next;
    }
  }

  /* Driver program to test above functions*/
  public static void main(String[] args)
  {

    /* Start with the empty list */
    GFG dll = new GFG();

    // Create the doubly linked list
    // 14 <-> 9 <-> 8 <-> 15 <-> 18
    dll.append(18);
    dll.append(15);
    dll.append(8);
    dll.append(9);
    dll.append(14);

    // Uncomment to view the list
    // cout << "Original List: ";
    // printList();
    deleteEvenParityNodes();

    // Modified List
    printlist();
  }
}

// This code is contributed by rj13to.

// Java program to remove all
// the Even Parity Nodes from a
// circular singly linked list
class GFG{

// Structure for a node
static class Node 
{
    int data;
    Node next;
};

// Function to insert a node at
// the beginning of a Circular
// linked list
static Node push(Node head_ref, int data)
{
    
    // Create a new node
    // and make head as next
    // of it.
    Node ptr1 = new Node();

    Node temp = head_ref;
    ptr1.data = data;
    ptr1.next = head_ref;

    // If linked list is not null then
    // set the next of last node
    if (head_ref != null)
    {
        
        // Find the node before head
        // and update next of it.
        while (temp.next != head_ref)
            temp = temp.next;

        temp.next = ptr1;
    }
    else

        // Point for the first node
        ptr1.next = ptr1;

    head_ref = ptr1;
    return head_ref;
}

// Function to delete the node 
// from a Circular Linked list
static void deleteNode(Node head_ref,
                       Node del)
{
    
    // If node to be deleted is
    // head node
    if (head_ref == del)
        head_ref = del.next;

    Node temp = head_ref;

    // Traverse list till not found
    // delete node
    while (temp.next != del)
    {
        temp = temp.next;
    }

    // Copy the address of the node
    temp.next = del.next;

    // Finally, free the memory
    // occupied by del
    System.gc();

    return;
}

// Function that returns true if count
// of set bits in x is even
static boolean isEvenParity(int x)
{
    
    // Parity will store the
    // count of set bits
    int parity = 0;
    
    while (x != 0)
    {
        if ((x & 1) != 0)
            parity++;
            
        x = x >> 1;
    }

    if (parity % 2 == 0)
        return true;
    else
        return false;
}

// Function to delete all the 
// Even Parity Nodes from the
// singly circular linked list
static void deleteEvenParityNodes(Node head)
{
    if (head == null)
        return;

    if (head == head.next) 
    {
        if (isEvenParity(head.data))
            head = null;
            
        return;
    }

    Node ptr = head;
    Node next;

    // Traverse the list till the end
    do 
    {
        next = ptr.next;

        // If the node's data has 
        // even parity, delete node 'ptr'
        if (isEvenParity(ptr.data))
            deleteNode(head, ptr);

        // Point to the next node
        ptr = next;

    } while (ptr != head);

    if (head == head.next)
    {
        if (isEvenParity(head.data))
            head = null;
            
        return;
    }
}

// Function to print nodes in a
// given Circular linked list
static void printList(Node head)
{
    if (head == null)
    {
        System.out.print("Empty List\n");
        return;
    }

    Node temp = head;
    if (head != null)
    {
        do 
        {
            System.out.printf("%d ", temp.data);
            temp = temp.next;
        } while (temp != head);
    }
}

// Driver code
public static void main(String[] args)
{
    
    // Initialize lists as empty
    Node head = null;

    // Created linked list will be
    // 11.9.34.6.13.21
    head = push(head, 21);
    head = push(head, 13);
    head = push(head, 6);
    head = push(head, 34);
    head = push(head, 9);
    head = push(head, 11);

    deleteEvenParityNodes(head);

    printList(head);
}
}

// This code is contributed by Amit Katiyar