有一个单向链表，链表中有可能出现“环”，判断该链表是否为有环链表

• 问题：

有一个单向链表，链表中有可能出现“环”，写出程序判断该链表是否为有环链表

• 解释：

在Java中，检测单向链表中是否存在环的最优化算法之一是“快慢指针”算法（也称为Floyd的乌龟和兔子算法）。该算法使用两个指针，一个快指针（每次移动两步）和一个慢指针（每次移动一步）。如果链表中存在环，那么快指针最终会追上慢指针，它们会在环内的某个位置相遇。如果链表中没有环，那么快指针会先到达链表的末尾（null）。

• 代码

以下是使用Java实现的示例代码：

public class ListNode {  
    int val;  
    ListNode next;  
    ListNode(int x) { val = x; }  
}  
  
public class LinkedListCycle {  
    public boolean hasCycle(ListNode head) {  
        if (head == null || head.next == null) {  
            return false;  
        }  
          
        ListNode slow = head;  
        ListNode fast = head.next;  
          
        while (slow != fast) {  
            if (fast == null || fast.next == null) {  
                return false; // 没有环，快指针已经到达链表末尾  
            }  
            slow = slow.next; // 慢指针前进一步  
            fast = fast.next.next; // 快指针前进两步  
        }  
          
        return true; // 快慢指针相遇，说明有环  
    }  
  
    public static void main(String[] args) {  
        // 示例：构造一个有环的链表  
        ListNode node1 = new ListNode(3);  
        ListNode node2 = new ListNode(2);  
        ListNode node3 = new ListNode(0);  
        ListNode node4 = new ListNode(-4);  
  
        node1.next = node2;  
        node2.next = node3;  
        node3.next = node4;  
        node4.next = node2; // 创建一个环  
  
        LinkedListCycle cycleDetector = new LinkedListCycle();  
        System.out.println("链表是否有环？ " + cycleDetector.hasCycle(node1)); // 输出 true  
  
        // 示例：构造一个无环的链表  
        ListNode node5 = new ListNode(1);  
        ListNode node6 = new ListNode(2);  
        ListNode node7 = new ListNode(3);  
  
        node5.next = node6;  
        node6.next = node7;  
        node7.next = null;  
  
        System.out.println("链表是否有环？ " + cycleDetector.hasCycle(node5)); // 输出 false  
    }  
}

在这段代码中，ListNode 是链表节点的定义，每个节点包含一个整数值和一个指向下一个节点的指针。LinkedListCycle 类包含一个 hasCycle 方法，该方法接收链表的头节点作为参数，并返回一个布尔值，指示链表中是否存在环。在 main 方法中，我们创建了两个示例链表，一个包含环，另一个不包含环，以演示 hasCycle 方法的使用。