从双循环单链表中删除所有偶校验节点

给定一个包含N 个节点的双向链表和循环单向链表，任务是从每个包含奇偶校验元素的列表中删除所有节点。

例子：

Input: CLL = 9 -> 11 -> 34 -> 6 -> 13 -> 21 
Output: 11 -> 13 -> 21 
Explanation: 
The circular singly linked list contains : 
11 -> 1011, parity = 3 
9 -> 1001, parity = 2 
34 -> 100010, parity = 2 
6 -> 110, parity = 2 
13 -> 1101, parity = 3 
21 -> 10101, parity = 3 
Here, parity for nodes containing 9, 34, and 6 are even. 
Hence, these nodes have been deleted.

Input: DLL = 18 <=> 15 <=> 8 <=> 9 <=> 14 
Output: 8 <=> 14 
Explanation: 
The linked list contains : 
18 -> 10010, parity = 2 
15 -> 1111, parity = 4 
8 -> 1000, parity = 1 
9 -> 1001, parity = 2 
14 -> 1110, parity = 3 
Here, parity for nodes containing 18, 15 and 9 are even. 
Hence, these nodes have been deleted. 

方法：
一个简单的方法是逐个遍历列表的节点，首先对每个节点，通过迭代每一位找到节点中存在的值的奇偶校验，然后最后删除奇偶校验为偶数的节点。

双向链表

下面是上述方法的实现：

C++

// C++ implementation to remove all
// the Even Parity Nodes from a
// doubly linked list
 
#include 
 
using namespace std;
 
// Node of the doubly linked list
struct Node {
    int data;
    Node *prev, *next;
};
 
// Function to insert a node at the beginning
// of the Doubly Linked List
void push(Node** head_ref, int new_data)
{
    // Allocate the node
    Node* new_node
        = (Node*)malloc(sizeof(struct Node));
 
    // Insert the data
    new_node->data = new_data;
 
    // Since we are adding at the beginning,
    // prev is always NULL
    new_node->prev = NULL;
 
    // Link the old list off the new node
    new_node->next = (*head_ref);
 
    // Change the prev of
    // head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;
 
    // Move the head to point
    // to the new node
    (*head_ref) = new_node;
}
 
// Function that returns true if count
// of set bits in x is even
bool isEvenParity(int x)
{
    // parity will store the
    // count of set bits
    int parity = 0;
    while (x != 0) {
        if (x & 1)
            parity++;
        x = x >> 1;
    }
 
    if (parity % 2 == 0)
        return true;
    else
        return false;
}
 
// Function to delete a node
// in a Doubly Linked List.
// head_ref --> pointer to head node pointer.
// del --> pointer to node to be deleted
void deleteNode(Node** head_ref, Node* del)
{
    // Base case
    if (*head_ref == NULL || del == NULL)
        return;
 
    // If the node to be
    // deleted is head node
    if (*head_ref == del)
        *head_ref = 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
    free(del);
 
    return;
}
 
// Function to to remove all
// the Even Parity Nodes from a
// doubly linked list
void deleteEvenParityNodes(
    Node** head_ref)
{
    Node* ptr = *head_ref;
    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(head_ref, ptr);
 
        ptr = next;
    }
}
 
// Function to print nodes in a
// given doubly linked list
void printList(Node* head)
{
    if (head == NULL) {
        cout << "Empty list\n";
        return;
    }
 
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}
 
// Driver Code
int main()
{
 
    Node* head = NULL;
 
    // Create the doubly linked list
    // 18 <-> 15 <-> 8 <-> 9 <-> 14
    push(&head, 14);
    push(&head, 9);
    push(&head, 8);
    push(&head, 15);
    push(&head, 18);
 
    // Uncomment to view the list
    // cout << "Original List: ";
    // printList(head);
 
    deleteEvenParityNodes(&head);
 
    // Modified List
    printList(head);
}

Python3

# Python3 implementation to remove all
# the Even Parity Nodes from a
# doubly linked list
  
# Node of the doubly linked list
class Node:
     
    def __init__(self):
         
        self.data = 0
        self.prev = None
        self.next = None
  
# Function to insert a node at the
# beginning of the Doubly Linked List
def push(head_ref, new_data):
 
    # Allocate the node
    new_node = Node()
  
    # Insert the data
    new_node.data = new_data
  
    # Since we are adding at the
    # beginning, prev is always None
    new_node.prev = None
  
    # Link the old list off the new node
    new_node.next = (head_ref)
  
    # Change the prev of
    # head node to new node
    if ((head_ref) != None):
        (head_ref).prev = new_node
  
    # Move the head to point
    # to the new node
    (head_ref) = new_node
     
    return head_ref
 
# Function that returns true if count
# of set bits in x is even
def isEvenParity(x):
 
    # parity will store the
    # count of set bits
    parity = 0
     
    while (x != 0):
        if (x & 1):
            parity += 1
             
        x = x >> 1
  
    if (parity % 2 == 0):
        return True
    else:
        return False
 
# Function to delete a node
# in a Doubly Linked List.
# head_ref -. pointer to head node pointer.
# delt -. pointer to node to be deleted
def deleteNode(head_ref, delt):
 
    # Base case
    if (head_ref == None or delt == None):
        return
  
    # If the node to be
    # deleted is head node
    if (head_ref == delt):
        head_ref = delt.next
  
    # Change next only if node to be
    # deleted is not the last node
    if (delt.next != None):
        delt.next.prev = delt.prev
  
    # Change prev only if node to be
    # deleted is not the first node
    if (delt.prev != None):
        delt.prev.next = delt.next
  
    # Finally, free the memory
    # occupied by delt
    del(delt)
  
    return head_ref
 
# Function to to remove all
# the Even Parity Nodes from a
# doubly linked list
def deleteEvenParityNodes(head_ref):
 
    ptr = head_ref
    next = None
  
    # Iterating through
    # the linked list
    while (ptr != None):
        next = ptr.next
  
        # If node's data's parity
        # is even
        if (isEvenParity(ptr.data)):
            head_ref = deleteNode(head_ref, ptr)
  
        ptr = next
         
    return head_ref
     
# Function to print nodes in a
# given doubly linked list
def printList(head):
 
    if (head == None):
        print("Empty list\n")
        return
 
    while (head != None):
        print(head.data, end = ' ')
        head = head.next
  
# Driver Code
if __name__=='__main__':
  
    head = None
     
    # Create the doubly linked list
    # 18 <. 15 <. 8 <. 9 <. 14
    head = push(head, 14)
    head = push(head, 9)
    head = push(head, 8)
    head = push(head, 15)
    head = push(head, 18)
  
    # Uncomment to view the list
    # cout << "Original List: ";
    # printList(head);
    head = deleteEvenParityNodes(head)
  
    # Modified List
    printList(head)
 
# This code is contributed by rutvik_56

输出：

8 14

循环单向链表

下面是上述方法的实现：

C++

// C++ program to remove all
// the Even Parity Nodes from a
// circular singly linked list
 
#include 
using namespace std;
 
// Structure for a node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to insert a node at the beginning
// of a Circular linked list
void push(struct Node** head_ref, int data)
{
    // Create a new node
    // and make head as next
    // of it.
    struct Node* ptr1
        = (struct Node*)malloc(
            sizeof(struct Node));
 
    struct 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;
}
 
// Function to delete the node from a
// Circular Linked list
void deleteNode(
    Node*& head_ref, Node* del)
{
    // If node to be deleted is head node
    if (head_ref == del)
        head_ref = del->next;
 
    struct 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
    free(del);
 
    return;
}
 
// Function that returns true if count
// of set bits in x is even
bool isEvenParity(int x)
{
    // parity will store the
    // count of set bits
    int parity = 0;
    while (x != 0) {
        if (x & 1)
            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
void deleteEvenParityNodes(Node*& head)
{
    if (head == NULL)
        return;
 
    if (head == head->next) {
        if (isEvenParity(head->data))
            head = NULL;
        return;
    }
 
    struct Node* ptr = head;
 
    struct 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
void printList(struct Node* head)
{
    if (head == NULL) {
        cout << "Empty List\n";
        return;
    }
 
    struct Node* temp = head;
    if (head != NULL) {
        do {
            printf("%d ", temp->data);
            temp = temp->next;
        } while (temp != head);
    }
}
 
// Driver code
int main()
{
    // Initialize lists as empty
    struct Node* head = NULL;
 
    // Created linked list will be
    // 11->9->34->6->13->21
    push(&head, 21);
    push(&head, 13);
    push(&head, 6);
    push(&head, 34);
    push(&head, 9);
    push(&head, 11);
 
    deleteEvenParityNodes(head);
 
    printList(head);
 
    return 0;
}

Java

// 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

蟒蛇3

# Python3 program to remove all
# the Even Parity Nodes from a
# circular singly linked list
  
# Structure for a node
class Node:
     
    def __init__(self):
         
        self.data = 0
        self.next = None
  
# Function to insert a node at the beginning
# of a Circular linked list
def push(head_ref, data):
 
    # Create a new node
    # and make head as next
    # of it.
    ptr1 = Node()
          
    temp = head_ref;
    ptr1.data = data;
    ptr1.next = head_ref;
  
    # If linked list is not None then
    # set the next of last node
    if (head_ref != None):
  
        # Find the node before head
        # and update next of it.
        while (temp.next != head_ref):
            temp = temp.next;
  
        temp.next = ptr1;
     
    else:
  
        # Pofor the first node
        ptr1.next = ptr1;
  
    head_ref = ptr1;
     
    return head_ref
  
# Function to deltete the node from a
# Circular Linked list
def delteteNode( head_ref, delt):
 
    # If node to be delteted is head node
    if (head_ref == delt):
        head_ref = delt.next;
  
    temp = head_ref;
  
    # Traverse list till not found
    # deltete node
    while (temp.next != delt):
        temp = temp.next;
  
    # Copy the address of the node
    temp.next = delt.next;
  
    # Finally, free the memory
    # occupied by delt
    del(delt);
  
    return head_ref;
  
# Function that returns true if count
# of set bits in x is even
def isEvenParity(x):
 
    # parity will store the
    # count of set bits
    parity = 0;
    while (x != 0):
        if (x & 1) != 0:
            parity += 1
        x = x >> 1;
      
    if (parity % 2 == 0):
        return True;
    else:
        return False;
  
# Function to deltete all
# the Even Parity Nodes
# from the singly circular linked list
def delteteEvenParityNodes(head):
 
    if (head == None):
        return head;
  
    if (head == head.next):
        if (isEvenParity(head.data)):
            head = None;
        return head;
     
    ptr = head;
  
    next = None
  
    # Traverse the list till the end
    while True:
 
        next = ptr.next;
  
        # If the node's data has even parity,
        # deltete node 'ptr'
        if (isEvenParity(ptr.data)):
            head=delteteNode(head, ptr);
  
        # Poto the next node
        ptr = next;
         
        if(ptr == head):
            break
 
    if (head == head.next):
        if (isEvenParity(head.data)):
            head = None;
        return head;
         
    return head;
    
# Function to prnodes in a
# given Circular linked list
def printList(head):
 
    if (head == None):
        print("Empty List")
        return;
  
    temp = head;
     
    if (head != None):       
        while True:           
            print(temp.data, end=' ')
            temp = temp.next
             
            if temp == head:
                break
             
# Driver code
if __name__=='__main__':
     
    # Initialize lists as empty
    head = None;
  
    # 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);
  
    head=delteteEvenParityNodes(head);
  
    printList(head);
  
# This code is contributed by pratham_76

C＃

// C# program to remove all
// the Even Parity Nodes from a
// circular singly linked list
using System;
class GFG{
 
// Structure for a node
public class Node
{
  public int data;
  public 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;
 
  return;
}
 
// Function that returns true
// if count of set bits in x
// is even
static bool 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)
  {
    Console.Write("Empty List\n");
    return;
  }
 
  Node temp = head;
  if (head != null)
  {
    do
    {
      Console.Write(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 Rajput-Ji

Javascript

 
// Javascript program to remove all
// the Even Parity Nodes from a
// circular singly linked list
 
// Structure for a node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Function to insert a node at
// the beginning of a Circular
// linked list
function push(head_ref, data)
{
     
    // Create a new node
    // and make head as next
    // of it.
    var ptr1 = new Node();
 
    var 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
function deleteNode(head_ref, del)
{
     
    // If node to be deleted is
    // head node
    if (head_ref == del)
        head_ref = del.next;
 
    var 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
    return;
}
 
// Function that returns true if count
// of set bits in x is even
function isEvenParity(x)
{
     
    // Parity will store the
    // count of set bits
    var 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
function deleteEvenParityNodes(head)
{
    if (head == null)
        return;
 
    if (head == head.next)
    {
        if (isEvenParity(head.data))
            head = null;
 
        return;
    }
     
    var ptr = head;
    var 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 prvar nodes in a
// given Circular linked list
function printList(head)
{
    if (head == null)
    {
        document.write("Empty List\n");
        return;
    }
     
    var temp = head;
    if (head != null)
    {
        do
        {
            document.write(temp.data + " ");
            temp = temp.next;
        } while (temp != head);
    }
}
 
// Driver code
 
// Initialize lists as empty
var 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 gauravrajput1
 

输出：

11 13 21

时间复杂度： O(K*N) ，其中 N 是链表的大小，K 是链表中存在的最大数量的位数。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live