计算给定循环链表中的重复项

给定一个循环链表，任务是检查给定链表是否有重复。

例子：

Input: list = {5, 7, 5, 1, 4, 4}
Output: 2
Explanation: The given list has 2 indices having integers which has already occurred in the list during traversal.

Input: list = {1, 1, 1, 1, 1}
Output: 4

方法：给定的问题有一个非常相似的解决方案来查找链表中的重复计数。这个想法是使用散列。使用这里讨论的算法遍历给定的循环链表。创建一个哈希图来存储列表中出现的整数，并为每个整数检查该整数是否已经出现。维护变量中已经出现的整数的计数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
  
// Class to store Node of the list
class Node {
public:
    int data;
    Node* next;
   
      Node(int data) {
         this->data = data;
          this->next = NULL;
    }
};
  
// Function to find the count of the
// duplicate integers in the list
static int checkDuplicate(Node* head)
{
    if (head == NULL)
        return 0;
 
    // Stores the count of duplicate
    // integers
    int cnt = 0;
 
    // Stores the integers occurred
    set s;
    s.insert(head->data);
    Node *curr = head->next;
 
    // Loop to traverse the given list
    while (curr != head) {
 
        // If integer already occurred
        if (s.find(curr->data) != s.end())
            cnt++;
 
        // Add current integer into
        // the hashmap
        s.insert(curr->data);
        curr = curr->next;
    }
 
    // Return answer
    return cnt;
}
 
// Driver Code
int main()
{
   
      Node *head = new Node(5);
    head->next = new Node(7);
      head->next->next = new Node(5);
    head->next->next->next = new Node(1);
    head->next->next->next->next = new Node(4);
    head->next->next->next->next->next = new Node(4);
    head->next->next->next->next->next->next = head;
 
    cout << checkDuplicate(head) << endl;
  
 
    return 0;
}
  
// This code is contributed by Dharanendra L V.

Java

// Java program for the above approach
 
import java.util.HashSet;
 
class GFG {
 
    // Class to store Node of the list
    static class Node {
        int data;
        Node next;
 
        public Node(int data)
        {
            this.data = data;
        }
    };
 
    // Stores head pointer of the list
    static Node head;
 
    // Function to find the count of the
    // duplicate integers in the list
    static int checkDuplicate(Node head)
    {
        if (head == null)
            return 0;
 
        // Stores the count of duplicate
        // integers
        int cnt = 0;
 
        // Stores the integers occurred
        HashSet s = new HashSet<>();
        s.add(head.data);
        Node curr = head.next;
 
        // Loop to traverse the given list
        while (curr != head) {
 
            // If integer already occurred
            if (s.contains(curr.data))
                cnt++;
 
            // Add current integer into
            // the hashmap
            s.add(curr.data);
            curr = curr.next;
        }
 
        // Return answer
        return cnt;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        head = new Node(5);
        head.next = new Node(7);
        head.next.next = new Node(5);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.next = new Node(4);
        head.next.next.next.next.next.next = head;
 
        System.out.println(checkDuplicate(head));
    }
}

Python3

# Python program for the above approach
 
# Class to store Node of the list
class Node:
    def __init__(self, data):
        self.data = data;
        self.next = None;
     
# Stores head pointer of the list
head = None;
 
# Function to find the count of the
# duplicate integers in the list
def checkDuplicate(head):
    if (head == None):
        return 0;
 
    # Stores the count of duplicate
    # integers
    cnt = 0;
 
    # Stores the integers occurred
    s = set();
    s.add(head.data);
    curr = head.next;
 
    # Loop to traverse the given list
    while (curr != head):
 
        # If integer already occurredA
        if ((curr.data) in s):
            cnt+=1;
 
        # Add current integer into
        # the hashmap
        s.add(curr.data);
        curr = curr.next;
     
    # Return answer
    return cnt;
 
# Driver Code
if __name__ == '__main__':
    head =  Node(5);
    head.next =  Node(7);
    head.next.next =  Node(5);
    head.next.next.next =  Node(1);
    head.next.next.next.next =  Node(4);
    head.next.next.next.next.next =  Node(4);
    head.next.next.next.next.next.next = head;
 
    print(checkDuplicate(head));
 
# This code is contributed by umadevi9616

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Class to store Node of the list
     class Node {
        public int data;
        public Node next;
 
        public Node(int data)
        {
            this.data = data;
        }
    };
 
    // Stores head pointer of the list
    static Node head;
 
    // Function to find the count of the
    // duplicate integers in the list
    static int checkDuplicate(Node head)
    {
        if (head == null)
            return 0;
 
        // Stores the count of duplicate
        // integers
        int cnt = 0;
 
        // Stores the integers occurred
        HashSet s = new HashSet();
        s.Add(head.data);
        Node curr = head.next;
 
        // Loop to traverse the given list
        while (curr != head) {
 
            // If integer already occurred
            if (s.Contains(curr.data))
                cnt++;
 
            // Add current integer into
            // the hashmap
            s.Add(curr.data);
            curr = curr.next;
        }
 
        // Return answer
        return cnt;
    }
 
    // Driver Code
    public static void Main()
    {
        head = new Node(5);
        head.next = new Node(7);
        head.next.next = new Node(5);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.next = new Node(4);
        head.next.next.next.next.next.next = head;
 
        Console.Write(checkDuplicate(head));
    }
}
 
// This code is contributed by ipg2016107.

Javascript

// javascript program for the above approach
 
    // Class to store Node of the list
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
    // Stores head pointer of the list
    var head;
 
    // Function to find the count of the
    // duplicate integers in the list
    function checkDuplicate(head) {
        if (head == null)
            return 0;
 
        // Stores the count of duplicate
        // integers
        var cnt = 0;
 
        // Stores the integers occurred
        var s = new Set();
        s.add(head.data);
var curr = head.next;
 
        // Loop to traverse the given list
        while (curr != head) {
 
            // If integer already occurred
            if (s.has(curr.data))
                cnt++;
 
            // Add current integer into
            // the hashmap
            s.add(curr.data);
            curr = curr.next;
        }
 
        // Return answer
        return cnt;
    }
 
    // Driver Code
        head = new Node(5);
        head.next = new Node(7);
        head.next.next = new Node(5);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.next = new Node(4);
        head.next.next.next.next.next.next = head;
 
        document.write(checkDuplicate(head));
 
// This code is contributed by gauravrajput1

输出：

2

时间复杂度： O(N)
辅助空间： O(N)