用于查找链表中循环长度的Java程序

编写一个函数detectAndCountLoop()检查给定的链表是否包含循环，如果存在循环，则返回循环中的节点数。例如，循环存在于下面的链接列表中，循环的长度为 4。如果循环不存在，则函数应返回 0。

方法：
众所周知，弗洛伊德的循环检测算法在快速和慢速指针在一个公共点相遇时终止。也知道这个公共点是循环节点之一。将此公共点的地址存储在指针变量say (ptr) 中。然后用 1 初始化一个计数器，从公共点开始，继续访问下一个节点并增加计数器，直到再次到达公共指针。
此时，计数器的值将等于循环的长度。
算法：

1. 使用 Floyd 循环检测算法找到循环中的公共点
2. 将指针存储在临时变量中并保持计数 = 0
3. 遍历链表，直到再次到达同一个节点，并在移动到下一个节点时增加计数。
4. 将计数打印为循环长度

Java

// Java program to count number of nodes
// in loop in a linked list if loop is
// present
import java.io.*;
 
class GFG
{
    // Link list node
    static class Node
    {
        int data;
        Node next;
        Node(int data)
        {
            this.data =data;
            next =null;
        }
    }
 
    // Returns count of nodes present
    // in loop.
    static int countNodes( Node n)
    {
        int res = 1;
        Node temp = n;
        while (temp.next != n)
        {
            res++;
            temp = temp.next;
        }
        return res;
    }
 
    /* This function detects and counts
       loop nodes in the list. If loop
       is not there in then returns 0 */
    static int countNodesinLoop( Node list)
    {
        Node slow_p = list,
             fast_p = list;
 
        while (slow_p !=null &&
               fast_p!=null &&
               fast_p.next!=null)
        {
            slow_p = slow_p.next;
            fast_p = fast_p.next.next;
 
            /* If slow_p and fast_p meet at some
               point then there is a loop */
            if (slow_p == fast_p)
                return countNodes(slow_p);
        }
 
        // Return 0 to indicate that there is
        // no loop
        return 0;
    }
 
    static Node newNode(int key)
    {
        Node temp = new Node(key);   
        return temp;
    }
 
    // Driver code
    public static void main (String[] args)
    {
        Node head = newNode(1);
        head.next = newNode(2);
        head.next.next = newNode(3);
        head.next.next.next = newNode(4);
        head.next.next.next.next = newNode(5);
 
        // Create a loop for testing
        head.next.next.next.next.next = head.next;
 
        System.out.println( countNodesinLoop(head));
    }
}
// This code is contributed by inder_verma.

输出：

4

复杂性分析：

• 时间复杂度： O(n)。
  只需要遍历一次链表。
• 辅助空间： O(1)。
  因为不需要额外的空间。

请参阅完整文章在链表中查找循环长度以获取更多详细信息！