LeetCode：环形链表II

1、题目描述

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内

• -105 <= Node.val <= 105

• pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？

2、方法1：哈希集合

解题思路

1. 初始化哈希集合：创建一个 HashSet 来存储已经访问过的节点引用（地址）。

2. 遍历链表：

   • 从链表头节点 head 开始，依次访问每个节点。

   • 对于当前节点 head：

     • 如果 head 已经存在于 HashSet 中：

       • 说明该节点是入环的第一个节点，直接返回该节点。

     • 如果 head 不在 HashSet 中：

       • 将该节点加入 HashSet，表示已经访问过。

       • 移动 head 指针到下一个节点（head = head.next）。

3. 遍历结束：

   • 如果 head 移动到 null，说明链表无环，返回 null。

关键点

• 哈希集合存储的是节点引用（地址），可以正确处理链表中有重复值的情况。

• 时间复杂度：O(n)，需要遍历整个链表。

• 空间复杂度：O(n)，最坏情况下需要存储所有节点。

//使用hashSet解题，第一次当判断set集合中存在该节点的时候，就是环的入口节点，也证明有环
    public static ListNode isCycleII(ListNode head){
        if (head == null) return null;
        HashSet<ListNode> hashSet = new HashSet<>();
        while (head != null){
            if (hashSet.contains(head)){
                return head;//有环，且遍历第一次判断该节点在set中存在，则是第一个环的入口
            }
            hashSet.add(head);
            head = head.next;
        }
        return null;//表示无环
    }

3、方法2：快慢指针

解题思路

1. 初始化指针：

   • 慢指针 last 和快指针 fast 都指向头节点 head。

2. 判断是否有环：

   • 使用快慢指针遍历链表：

     • 慢指针 last 每次移动一步（last = last.next）。

     • 快指针 fast 每次移动两步（fast = fast.next.next）。

   • 如果快慢指针相遇：

     • 说明链表有环，设置 isCycle = true 并退出循环。

   • 如果快指针遇到 null：

     • 说明链表无环，直接返回 null。

3. 寻找环的入口：

   • 如果有环，将慢指针 last 重新指向头节点 head。

   • 快慢指针同时每次移动一步，直到再次相遇：

     • 相遇的节点即为环的入口节点。

4. 返回结果：

   • 返回相遇的节点（环的入口）或 null（无环）。

关键点

• 快慢指针的速度差：

  • 慢指针每次移动一步，快指针每次移动两步。

  • 如果有环，快指针最终会追上慢指针。

• 环的入口定位：

  • 快慢指针相遇后，将慢指针重置到 head，然后快慢指针同步移动，再次相遇的点即为入口。

  • 

• 时间复杂度：O(n)，快指针遍历速度更快。

• 空间复杂度：O(1)，仅需两个指针，无需额外空间。

 // 使用快慢指针，先判断是否有环，如果有环的话，将慢指针重新指向头结点head，
    // 然后再遍历链表，快慢指针都每次直走一步，当两者再次相遇，则指向的结点就是环的入口节点
    public static ListNode isCycleII(ListNode head){
        if (head == null) return null;
        ListNode last = head, fast = head;
        boolean isCycle=false; //默认为false
        while (fast != null && fast.next != null && fast.next.next != null){
            last = last.next;
            fast = fast.next.next;
            if (fast == last ){//说明有环
                isCycle = true;
                break;
            }

        }
        if (isCycle){//有环
            last = head;
            while (last != fast){
                last = last.next;
                fast = fast.next;
            }
            //退出循环的时候，该节点就是环的入口节点
            return last;
        }
        return null;//如果上面都不成立，说明无环
    }