环形链表 II 详解：哈希表与 Floyd 快慢指针求环入口

环链表这道题，在刷题圈子里是个绕不过去的坎。它排在热门题库的经典链表题单里，表面上只是“判断链表有没有环、入口在哪”，实际上却把链表遍历、双指针思想、数学归纳和边界处理全串在了一起。很多人在第一眼看到题目时，第一反应就是“用哈希表存节点嘛”，做出来之后又觉得不够痛快，因为面试官大概率会追问一句：能不能把空间复杂度降下来。这篇博文就围绕这题的两个层次来展开——先讲最直观的哈希表思路，再彻底讲透Floyd判圈算法（也就是常说的快慢指针法）背后的数学原理、代码实现和实战细节。无论你是刚开始刷链表题，还是准备面试想把自己的解法讲得有说服力，这篇内容都值得顺着读一遍。

我写这篇文章的时候，默认你已经知道链表是什么，也能写出基本的单链表遍历代码。但如果你对“环入口”这个要求还不太敏感，或者看完网上各种题解总觉得证明有点跳，那这篇文章就是给你准备的。我会把每一步的“为什么”都掰开揉碎讲清楚，包括那些代码里看不见的推导过程。

1. 题目拆解：先看清题目在问什么

1.1 题面与两个隐藏要求

题目本身不长：给定一个链表，返回链表开始入环的第一个节点，如果链表无环，则返回null。注意这跟“判断链表是否有环”不是一回事。判环只要告诉你有环没环，个布尔值就完了；这道题要求你精确地指出入口节点在哪。

举个例子，一个链表从头到尾依次是 1 → 2 → 3 → 4 → 5，然后 5 的 next 又指回 3，那入口就是节点 3。很多人在这一步就开始犯迷糊：入口是“第一次重复出现的节点”吗？是，但也不全是。因为你没法用简单的值去判断，节点值可能重复，而你需要找的是“内存地址第一次回到环中某个节点”的位置，也就是环的起点。

这题有两个隐藏要求。第一，它默认链表节点里没有额外的visited标记位，你不能去改节点结构；第二，它要求空间复杂度尽量低。标准答案有两个层次：哈希表解法的空间复杂度是O(n)，Floyd判圈算法的空间复杂度是O(1)。这道题之所以能成为经典，并不只是因为它考了一个算法，而是因为它逼着你在“空间换时间”和“纯数学巧思”之间做一次选择。

1.2 为什么哈希表是第一直觉：从空间换时间说起

如果你第一次接触这题，想到哈希表太正常了。遍历链表的时候，每经过一个节点，就把节点的引用存进一个HashSet，然后在存之前先检查一下这个引用是否已经存在。如果某一次发现“这个节点见过了”，那这个节点就是环的入口；如果整条链表走到了null，就返回null。

这个思路的本质是：环存在的唯一标志，就是你在遍历过程中会第二次踩到同一个节点。而如果链表没有环，你必然会在某个时刻走到next为null的位置，遍历自然结束。

这里有个小细节很容易踩坑：HashSet里存的是节点的引用，不是节点的值。因为链表节点的val字段可能重复，比如入口是值为3的节点，环里另一个节点值也是3，如果按值存就会误判。Java里两个不同的ListNode对象即使val相同，equals和hashCode默认也是按对象地址来区分的，所以用HashSet直接存引用是安全的。

哈希表解法能做到时间O(n)、空间O(n)，代码很短，也好解释。它最大的价值是作为“基线解”，帮你在面试时先建立一个正确的解题框架：先判断能否用简单方法解决，再讨论如何优化。

1.3 面试官的灵魂追问：能不能把空间省下来

如果面试只要求“做出来”，哈希表版本已经可以交卷了。但大多数面试官不会满足于此。他们通常会在你说完哈希表解法之后追问：“如果不允许用额外空间，你还能做吗？”

这时候你就要意识到，空间复杂度O(n)意味着你记录了整条链表的信息，而链表本身是线性的，理论上可以用更少的额外状态去感知环的结构。这里需要引入的，就是Floyd判圈算法。它虽然已经有了上百年的数学渊源（最早可以追溯到龟兔赛跑的数学模型），但在算法面试里，它依然是“链表判环+找环入口”这一场景下最优雅、最省空间的解法。

我建议你把这题当成一个思维训练的样本：先写哈希表版本，再看Floyd版本。两个版本都吃透了，你对“双指针”和“数学建模”的理解会拔高一个层次。

2. Floyd判圈算法：从相遇点到环入口的距离秘密

2.1 经典的两阶段思想：找相遇点与找入口

Floyd判圈算法，在国内讨论里通常直接叫“快慢指针法”。它的基本思想是：设置两个指针，慢指针slow每次走一步，快指针fast每次走两步。如果链表无环，fast会率先走到null，问题结束；如果链表有环，fast和slow一定会在环内某个位置相遇。

找相遇点的代码很简单，真正难的是找到入口。Floyd算法的精妙之处在于：一旦快慢指针在环内相遇，你再让一个新指针从头节点出发，和slow指针保持同步、每次都走一步，这两个指针最终会在环的入口处相遇。这个结论初看有些反直觉：凭什么从相遇点走一步一个节点就能跟从头节点出发的指针在入口碰上？

要回答这个问题，必须做数学推导。我当初学这题的时候，也是只记结论不记推导，结果面试时一被追问就卡壳。后来发现，只要把路径长度用字母表示出来，一切都很清晰。

2.2 快慢指针为什么一定会相遇

我们先解决一个基础问题：为什么有环时，快指针和慢指针一定会在环里相遇？这个可以用相对速度来解释。

假设环的长度为C。快指针比慢指针每秒多走一步（因为一个是2步/轮，一个是1步/轮）。当慢指针刚进入环的时候，快指针早已经在环里转了不知道多少圈。把环想象成一条环形跑道，快指针在慢指针前方某个位置，但它相对慢指针的速度是1步/轮，意味着每一轮它都会把“相对距离”缩短1。因为环长度C是有限的，所以经过最多C轮，快指针一定能追上慢指针，追上时就是相遇的时刻。

这个推理有个前提：快指针每次走两步，它会不会“跳过”慢指针？不会。因为在每一轮内部，快指针会先移动一步，再移动一步；在同一个时间片内慢指针最多移动一步。如果两者距离为1，快指针第一步就追上了；如果距离为2，快指针第一步走了1，距离变成1，第二步再走就撞上了。所以不存在跳过的问题。

“一定会相遇”这个结论是后续所有推导的地基。如果不先想清楚它，后面讲D = nC - S的时候就会觉得特别突兀。

2.3 核心等式：D = nC - S 的推导

现在开始正式推导入口位置。为了描述方便，约定几个符号：

• D：从头节点到环入口节点的距离（按边数算，头节点到第一个入环节点需要走D步）。
• C：环的长度（环内节点数，也就是绕一圈需要C步）。
• S：从环入口到相遇点的距离（按慢指针在环内已经走过的步数算，且0 ≤ S < C）。
• n：快指针从进入环到相遇时，已经在环里绕过的完整圈数，n≥1。

慢指针从头走到相遇点的总路程是：D + S。这个比较好理解，它先走D步到达环入口，再在环内走了S步到相遇点。

快指针呢？它和慢指针同时出发，速度是慢指针的两倍，所以相同时间内它走的总路程是慢指针的两倍，即2(D + S)。

同时，快指针走过的路程还可以从另一条路径来理解：它同样先走D步到达环入口，然后进入环内绕圈。到相遇时为止，它在环内多走了n圈又加上S步，所以总路程是D + nC + S。

把两个式子放到同一个等式里：

2(D + S) = D + nC + S

两边同时消掉D + S，得到：

D + S = nC

也就是：

D = nC - S

这个式子的含义非常关键：从头节点到环入口的距离D，等于“绕n整圈的总长度”减去“从入口到相遇点的距离S”。

想象一下，如果有一个指针从相遇点出发，每走一步都出下一个节点，那么它走C - S步就能回到环入口（因为从相遇点到入口的距离正好是C - S）。如果它再多走几整圈，也就是走nC - S步，同样还是会停在入口。

D = nC - S正好说明：从相遇点出发的一个指针，走D步之后会到达环入口；从头节点出发的一个指针，同样走D步之后也会到达环入口。两者同时走、速度相同，必然在入口相遇。

这就是Floyd算法第二阶段能成立的原因：让一个新指针从头节点出发，让slow从相遇点出发，两者都以每次一步的速度前进，它们第一次相遇的位置，就是环入口。相遇的距离恰好是D，不多不少。

2.4 为什么快指针恰好走两步，走三步行不行

一个很自然的问题是：快指针每次必须走两步吗？走三步、走四步行不行？

从数学上说，走三步也可能相遇，但分析起来麻烦得多，而且可能出现效率不稳定的情况。快指针走两步的核心原因是：慢指针速度是1，快指针速度是2，两者的速度差正好是1。这样在环形跑道上，快指针每一轮都能把与慢指针的相对距离缩短1，保证在C轮内必然追上，且不会跳过。

如果快指针走三步，速度差变成2，当慢指针进环时，如果两者的相对距离是奇数，每一轮只能缩短2，有可能出现“刚好从慢指针头顶跨过去”的值。虽然最终通常还是会相遇（需要更精细的模运算分析），但代码和证明都会变得不优雅。

所以工程实践中约定俗成：快指针走两步，这是兼顾简洁性和正确性的最优解。面试时如果有人问你这个细节，你能说出“保持速度差为1，避免跳过”这个理由，就说明你是真的理解了这个算法，而不是死记硬背。

3. Java代码实现：两种解法的完整代码与关键细节

3.1 哈希表解法的实现

哈希表解法代码非常短，先给出完整版本：

java复制import java.util.HashSet;
import java.util.Set;

public class Solution {
    public ListNode detectCycle(ListNode head) {
        Set<ListNode> seen = new HashSet<>();
        ListNode cur = head;
        while (cur != null) {
            if (seen.contains(cur)) {
                return cur;
            }
            seen.add(cur);
            cur = cur.next;
        }
        return null;
    }
}

关键点有三个。第一个是判断顺序：必须先contains再add，否则第一次遍历到环入口时就会把自己当成“重复节点”返回，结果必然出错。第二个是HashSet的泛型必须是ListNode，不能是Integer，因为要按引用判断而不是按值判断。第三个是循环条件用cur != null，如果链表无环，最终cur会变成null，循环自然结束，返回null。

这个解法的时间复杂度是O(n)，空间复杂度是O(n)，胜在直观、不容易错。初学阶段先用它把题目逻辑理顺，再去看Floyd版本会轻松很多。

3.2 Floyd解法的完整实现

Floyd解法的完整Java代码如下：

java复制public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }

        ListNode slow = head;
        ListNode fast = head;

        // 第一阶段：快慢指针找相遇点
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                // 第二阶段：从头节点和相遇点同步出发，寻找环入口
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }

        return null;
    }
}

这段代码有几个细节值得单独讲。

首先，进入主循环前的判空：head == null 或 head.next == null 时直接返回null。这是因为fast.next.next这个访问依赖于fast和fast.next都不为空，提前拦住null可以避免循环内部的一堆空指针判断。当然也可以不写这个前置判空，完全依赖while条件里的fast != null && fast.next != null，但那样代码风格不够干净。

其次，主循环的出口条件。fast != null && fast.next != null是必须的。快指针一次跳两步，如果链表无环，fast可能会在倒数第二个节点或最后一个节点时发现自己下一步无法走完两步；如果不检查fast.next是否为null，访问fast.next.next就会抛NullPointerException。

第三，两个阶段的衔接。当slow == fast成立时，说明相遇点已经找到。这时直接进入第二阶段：一个新的ptr从头节点出发，slow继续从相遇点出发，两个指针都以每次一步的速度前进。while (ptr != slow)这个循环结束时，ptr就是环入口。

3.3 边界条件与空指针处理

链表题目最烦人的地方就是边界条件。这道题的边界主要集中在这几个场景：

无环且链表为空，返回null；无环且只有一个节点，返回null；无环但链表很长，慢指针和快指针永远不相遇，最终fast先走到null，循环退出返回null；有环但入口是头节点，此时D=0。第二阶段里ptr从头节点出发，slow从相遇点出发。由于D=0，ptr和slow会在第一步之前就已经指向同一个节点？不对，得仔细算一下。如果入口是头节点，那慢指针从头节点出发，先走D=0步就进环，它绕了若干圈后在环内某点相遇。第二阶段ptr=head，slow=相遇点，两个指针都走一步。ptr第一步走到第二个节点，slow第一步走到相遇点的下一个节点。它们什么时候相等？根据公式D=0，ptr需要走0步就到了入口（head），slow也需要走nC步才能回到入口，但nC是环长度的整数倍，slow从相遇点多绕几整圈确实会回到入口。ptr=head本身已经是入口，两者要同时到达入口的话，ptr需要原地等待slow绕完整圈。但代码里ptr也在移动，它每次走一步，会先离开入口往前走，绕到环里，再绕回来。从数学上，两个指针同时到达入口的那一次，ptr恰好是绕了若干圈后又回到入口的head，slow也回到入口。因为两者速度相同，D=0时它们在head相遇。这个case在代码里依然成立，但比较反直觉，我建议自己推演一遍。

这里有一个更隐蔽的问题：在第二阶段，如果链表很长、环很小，slow需要绕很多圈才能在入口和ptr相遇吗？不会。根据D = nC - S，两者相遇时总共走了D步。D是一个固定值（从头节点到入口的距离），而不是循环很多圈。数学已经帮我们保证了它们的第一次相遇就发生在入口，不需要额外等待。

4. 动手推演：一个具体链表从头走到尾

4.1 构造示例链表与初始状态

光看代码和公式还是有点抽象。我用一个具体的链表把整个流程走一遍。

构造链表如下：节点A → 节点B → 节点C → 节点D → 节点E，其中E的next指向C。也就是说，链表结构是 1 → 2 → 3 → 4 → 5 → 3，环入口是节点3。

按前面定义的符号：头节点到入口的距离D=2步（1走到2，2走到3）；环长度C=3（3→4→5→3）；慢指针进入环后，在环内走了S步到相遇点。

初始时，slow = 节点1，fast = 节点1，两者都在头节点。

4.2 第一阶段逐轮模拟表

我把每一轮结束后slow和fast的位置列出来，步数按从初始位置出发开始计数。

相遇点就是节点4。

现在验证一下符号：D=2，C=3，S是从入口3到相遇点4的距离，S=1。快指针在环内绕的圈数n：快指针从入口3到相遇点4走的路程是3（3→4→5→3→4），但它是在进入环之后总共走了D + 3？用等式验证：2(D+S) = D + nC + S，即 2(2+1) = 2 + n*3 + 1，得到6 = 3 + 3n，n=1。符合。

4.3 第二阶段用等式验证入口

进入第二阶段后，ptr = 头节点1，slow = 相遇点4。两个指针同步一次走一步。

• 第1步：ptr到2，slow到5
• 第2步：ptr到3，slow到3

同步到第2步时，两者在节点3相遇，节点3正是环入口。

这里有一个很妙的验证方法：用D = nC - S来看。D=2，n=1，C=3，S=1，等式两边都是2。相遇点4走两步可以回入口：4→5（1步），5→3（2步）。头节点走两步可以到入口：1→2（1步），2→3（2步）。所以两个方向的指针走相同的步数，殊途同归，恰好都落在入口。

5. 常见问题与经验笔记

5.1 刷题和面试时的高频疑问

这里整理一下我自己带人刷题时遇到最高频的疑问，列成表格方便对照。

还有一个很多人在面试时容易忽略的点：链表有环时，怎么求环的长度？其实只要让快慢指针相遇后，保持slow不动，让fast以每次一步的速度继续绕圈，数到再次回到slow所在位置，圈数就是环的长度C。这个技巧可以作为Floyd算法的自然延伸，面试官追问时可以秀一手。

5.2 从这道题延伸出去的能力

环形链表II这种题，训练的核心能力不只是“记一个算法”，而是抽象思维：把一个空间问题转成数学建模问题。

Floyd判圈算法其实不只适用于链表。判断一个迭代过程是否陷入循环（比如随机数生成器、状态机、函数式递归映射），都可以用同样的思路。核心思想只有一个：如果两个速度不同的指针在同一个有限状态空间里运动，它们早晚会重合；重合就说明存在循环。

数组相关的题目里也有类似的思路。比如某个数组问题要求你找出重复元素，如果给定的是一个值域连续、类似“索引+数值”的映射关系，就可以把它抽象成链表环的问题，用Floyd思想做O(1)空间解法。这类题目在面试里就像变装游戏，本质都是龟兔赛跑。

再比如链表题里还有一道“找链表中点”的经典题，也是快慢指针：快指针每次两步，慢指针每次一步，快指针到终点时慢指针正好在中点。包括“判断回文链表”时，通常也要先快慢指针找中点，再反转后半部分。掌握了快慢指针这一招，很多题都会变得顺手很多。

5.3 个人实操心得

这道题我在不同阶段写过四五个版本，踩过几次坑之后也总结了一些实际经验。

初次接触时建议先写哈希表版本。不是因为它简单，而是因为它是“正确性最容易验证”的版本。你可以先用哈希版本跑通所有测试用例，对题目的行为有感性认识。然后再切换到Floyd版本，这时你会有意识地去比较两个版本的差异，对“空间复杂度”的理解会更具体。

写Floyd版本时，最常犯的错误是第二阶段忘了重置指针。有人会在快慢相遇后，直接让fast从头出发，让slow留在相遇点，然后一起走。这是可以的。也有人会让slow从头出发，fast从相遇点出发，同样可以。但如果你只让一个指针从头走，另一个指针留在原地不动，那循环就永远不会终止。写代码前先把第二阶段的两个指针分别是谁想清楚，是避免卡壳的最有效办法。

调试链表环的代码时，我喜欢在代码里临时加一个计数器，限制循环次数。比如设置一个maxIterations = 10000，超过就抛异常来排查死循环。这在处理复杂用例时很管用，尤其是当你怀疑“会不会相遇”的时候，用计数器强制退出可以快速验证自己的推演。

这题还有一个容易忽视的点：如果面试官要求你只能修改链表结构，或者不允许使用额外的标记字段，你会怎么做？哈希表显然不行，Floyd正好满足。这也是它成为面试标准答案的原因之一。所以在准备这道题时，不仅要会写代码，还要能把推导过程用两三句话讲清楚：先证明相遇，再用速度关系推出D = nC - S，最后说明第二阶段为什么能定位入口。能把这个链条完整讲下来，这道题在面试里的价值就发挥到位了。

我在实际带人的过程中发现，一个能在白板上从容推导这道题的人，往往对链表和双指针都有了比较扎实的理解。反过来，只会背代码的人，一旦面试官换一个问法，比如“入口节点是头节点时怎么办”，就很容易露怯。把这篇文章里的模拟流程自己动手画一遍，比多刷十道简单题更有用。