【LeetCode】142. 环形链表 II（中等）——代码随想录算法训练营Day04

news2024/9/23 3:21:28

题目链接：142. 环形链表 II

题目描述

给定一个链表的头节点 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) 空间解决此题？

文章讲解：代码随想录

视频讲解：把环形链表讲清楚！如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

题解1：哈希表

思路：首先想到的方法是使用哈希表存储节点的状态（有没有被遍历过）。遍历链表并用 Map 存储每个节点是否已经被遍历过，若当前被遍历过，则此节点就是入环的节点。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    const nodesMap = new Map();
    let cur = head;
    while (cur) {
        if (nodesMap.get(cur)) {
            return cur;
        }
        nodesMap.set(cur, true);
        cur = cur.next;
    }
    return null;
};

分析：将整个链表完整遍历了一次，使用 Map 存储了所有节点，时间复杂度为 O(n)，空间复杂度为 O(n)。

题解2：快慢指针

思路：首先判断链表是否有环，如果有环，再找到环的入口。

1. 判断是否有环

可以定义快慢指针都指向链表头部，快指针每次走2步，慢指针每次走1步。如果存在环，则快指针一定会先进入环中，慢指针进入环后，快指针会以相对于慢指针一次1步的速度接近慢指针。即如果存在环，快慢指针一定会相遇；不存在环，快慢指针一定不会相遇。

2. 找到环的入口

快指针和慢指针相遇时，设快指针走了 f 步，慢指针走了 s 步。可以得出：

f = 2s ①

设链表在环外的长度为 a，环的长度为 b，快慢指针相遇时快指针已转过 n 圈（此时慢指针在环内必然还在第1圈，因为慢指针进入环后，快指针会以相对于慢指针一次1步的速度接近慢指针，快指针与慢指针的距离必然小于环的长度，因此慢指针在环内必然没有转够1圈），此时快指针比慢指针多转了 n 圈，可以得出：

f = s + nb ②

由 ① 和 ② 得：

s = nb ③

接下来让慢指针继续走 c 步走到环的入口处，设此时慢指针的总步数为 x，有：

x = k + nb ④

接下来只要求出 k 就可以找到环的入口处了，那么 k 为多少呢？慢指针在入口处停下时，走过的距离为：

x = a + nb ⑤

由 ④ 和 ⑤可得，k 等于 a，即快慢指针第1次相遇后，慢指针再走 a 步后到达入环口（这一步慢指针可能转了好几圈）。

因此得出结论，当快慢指针第1次相遇后，将快指针重置到链表头部，快慢指针以每次1步的速度同步移动，它们会在入环后再次相遇。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    let fast = slow = head; // 初始化快慢指针
    // 循环条件为快指针可以继续往后走2步
    while (fast && fast.next) {
        fast = fast.next.next; // 快指针每次前进2步
        slow = slow.next; // 慢指针每次前进1步
        // 快指针和慢指针相遇说明链表有环
        if (fast === slow) {
            fast = head; // 将 fast 重置
            // 快慢指针将在入环口第2次相遇
            while (fast !== slow) {
                fast = fast.next;
                slow = slow.next;
            }
            return fast;
        }
    }
    return null; // 链表没环
};

分析：快慢指针第1次相遇前，指针走的次数小于链表长度，快慢指针第1次相遇到第2次相遇，指针走的次数也小于链表长度，总体为走的次数小于 2n，时间复杂度为 O(n)，空间复杂度为 O(1)。