Java版LeetCode热题100之环形链表 II：从哈希表到Floyd判圈算法的深度解析

本文全面剖析 LeetCode 第142题「环形链表 II」，作为面试高频难题，我们将深入探讨两种核心解法，并重点掌握O(1)空间复杂度的Floyd判圈算法及其数学证明。无论你是算法新手还是经验丰富的开发者，都能从中获得系统性提升。

一、原题回顾

题目编号：LeetCode 142
题目名称：环形链表 II（Linked List Cycle II）
难度等级：中等（Medium）但极具挑战性

题目描述

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

如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。

注意：

• 评测系统使用整数pos来表示链表尾连接到链表中的位置（索引从0开始）
• pos不作为参数传递，仅用于标识链表实际情况
• 不允许修改链表

示例说明

示例 1：

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

图示：

3 → 2 → 0 → -4 ↑_________↓

示例 2：

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

图示：

1 → 2 ↑___↓

示例 3：

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

约束条件

• 链表中节点的数目范围在[0, 10⁴]内
• -10⁵ <= Node.val <= 10⁵
• pos的值为-1或者链表中的一个有效索引
• 进阶要求：使用 O(1) 空间解决此题
• 重要约束：不允许修改链表

节点定义

publicclassListNode{intval;ListNodenext;ListNode(intx){val=x;next=null;}}

二、原题分析

环形链表 II 是环形链表 I 的升级版，不仅要检测环的存在，还要精确定位环的入口：

🔑 关键洞察

1. 问题升级：从"是否存在环"到"环在哪里开始"
2. 精度要求：必须返回具体的入口节点，而非布尔值
3. 约束加强：明确禁止修改链表，排除了标记法等方案
4. 数学依赖：最优解法依赖于精妙的数学关系推导

🎯 解题目标

在满足时间O(n)、空间O(1)的前提下，准确找到环的入口节点。

❌ 常见误区

• 误区1：认为快慢指针相遇点就是入口 → 错误！相遇点通常不是入口
• 误区2：试图通过计数确定入口位置 → 无法确定环的具体结构
• 误区3：忽略边界情况处理 → 空链表、单节点等特殊情况

三、答案构思

我们将构建两种主要解法，体现不同的解决问题思路：

✅ 方法一：哈希表（Hash Set）

• 思路：记录已访问的节点，首次重复访问的节点即为入口
• 优点：直观易懂，代码简单，逻辑清晰
• 缺点：空间复杂度O(n)，不满足进阶要求

✅ 方法二：快慢指针（Floyd判圈算法）⭐️

• 思路：利用数学关系，在快慢指针相遇后，通过第三个指针找到入口
• 优点：空间复杂度O(1)，满足进阶要求，时间效率高
• 缺点：需要理解复杂的数学推导，初始实现容易出错

下面详细展开两种方法。

四、完整答案（Java 实现）

方法一：哈希表

importjava.util.HashSet;importjava.util.Set;publicclassSolution{publicListNodedetectCycle(ListNodehead){// 边界情况：空链表if(head==null){returnnull;}Set<ListNode>visited=newHashSet<>();ListNodecurrent=head;while(current!=null){// 如果当前节点已访问过，说明找到了环的入口if(visited.contains(current)){returncurrent;}// 记录当前节点visited.add(current);current=current.next;}returnnull;// 到达null，无环}}

方法二：快慢指针（Floyd判圈算法）

publicclassSolution{publicListNodedetectCycle(ListNodehead){// 边界情况：空链表if(head==null){returnnull;}// 第一阶段：检测环的存在ListNodeslow=head;ListNodefast=head;// 寻找快慢指针相遇点while(fast!=null&&fast.next!=null){slow=slow.next;// 慢指针走1步fast=fast.next.next;// 快指针走2步// 快慢指针相遇，说明存在环if(slow==fast){// 第二阶段：找到环的入口ListNodeptr=head;// 从头开始的新指针// ptr和slow以相同速度移动，相遇点即为入口while(ptr!=slow){ptr=ptr.next;slow=slow.next;}returnptr;}}returnnull;// 无环}}

💡关键设计：

• 第一阶段：快慢指针检测环并找到相遇点
• 第二阶段：从头节点和相遇点同时出发，找到入口

五、代码分析

方法一：哈希表

执行流程：

1. 创建HashSet存储已访问的节点引用
2. 遍历链表，对每个节点：
   • 检查是否已在Set中
   • 如果存在，立即返回该节点（环的入口）
   • 如果不存在，添加到Set中
3. 如果遍历到null，返回null

优点：

• 逻辑直观：符合"第一次重复就是入口"的直觉
• 早期返回：一旦找到入口立即返回，无需完整遍历
• 易于调试：每步操作都有明确目的

缺点：

• 空间开销大：最坏情况下存储所有n个节点
• 哈希计算：每次contains()和add()都有哈希计算开销
• 内存局部性：HashSet的内存布局不如数组连续

关键细节：

• 使用contains()检查存在性，而不是依赖add()的返回值
• 比较的是节点引用而非值，确保正确性

方法二：快慢指针（Floyd判圈算法）

数学原理详解：

让我们用图示来理解这个精妙的算法：

A → B → C → D → E ↑ ↓ H ← G ← F

假设：

• A到C的距离为a（环外部分）
• C到E的距离为b（环内相遇前的部分）
• E到C的距离为c（环内相遇后的部分）
• 环的总长度为L = b + c

当快慢指针相遇时：

• 慢指针走过的距离：a + b
• 快指针走过的距离：a + b + nL（n为快指针在环内绕的圈数）

由于快指针速度是慢指针的2倍：

2(a + b) = a + b + nL => 2a + 2b = a + b + n(b + c) => a + b = n(b + c) => a = n(b + c) - b => a = (n-1)(b + c) + c

关键洞察：a = (n-1)L + c

这意味着：

• 从链表头部到入口的距离a
• 等于从相遇点到入口的距离c加上(n-1)圈环长

因此，如果我们：

1. 从链表头部启动一个指针ptr
2. 从相遇点启动慢指针slow
3. 两者都以速度1移动

它们将在入口处相遇！

执行流程示例（示例1：[3,2,0,-4], pos=1）：

第一阶段：找相遇点

• 初始：slow=3, fast=3
• 轮次1：slow=2, fast=0
• 轮次2：slow=0, fast=2（fast: 0→-4→2）
• 轮次3：slow=2, fast=0（slow: 0→-4→2, fast: 2→0→-4→2→0？）

等等，让我们重新仔细计算：

链表结构：3→2→0→-4→2（回到索引1）

• 初始：slow=3, fast=3
• 轮次1：slow=2, fast=0（fast: 3→2→0）
• 轮次2：slow=0, fast=2（fast: 0→-4→2）
• 轮次3：slow=-4, fast=-4（slow: 0→-4, fast: 2→0→-4）
• 相遇点：-4

第二阶段：找入口

• ptr=3, slow=-4
• 轮次1：ptr=2, slow=2（ptr: 3→2, slow: -4→2）
• 相遇！返回节点2（入口）

优点：

• 空间最优：仅使用三个指针变量
• 时间高效：最多3n次操作（检测+定位）
• 无副作用：完全不修改原链表
• 数学优雅：基于严格的数学推导

关键细节：

• 循环条件：fast != null && fast.next != null（防止空指针）
• 相遇判断：在移动后立即检查slow == fast
• 第二阶段：必须在确认有环后才执行

六、时间复杂度和空间复杂度分析

详细推导（快慢指针）

时间复杂度：

• 第一阶段（检测环）：
  • 无环情况：快指针走完n个节点，O(n)
  • 有环情况：慢指针最多走n步，O(n)
• 第二阶段（找入口）：
  • 从头到入口最多n步，O(n)
• 总计：O(n) + O(n) = O(n)

空间复杂度：

• 仅使用slow、fast、ptr三个指针变量
• 无递归调用栈
• 总计：O(1)

📊性能对比（n=10000）：

• 哈希表：10000次操作 + 10000个对象存储 + 哈希计算开销
• 快慢指针：≤30000次操作 + 3个指针变量

在内存受限环境或大规模数据场景下，快慢指针优势极其明显！

七、问题解答（FAQ）

Q1：为什么快慢指针相遇后，从头开始的指针和慢指针会在入口相遇？

答：这是Floyd判圈算法的核心数学保证，让我们重新推导：

设：

• a= 头节点到入口的距离
• b= 入口到相遇点的距离
• c= 相遇点到入口的距离（环的剩余部分）
• L = b + c= 环的总长度

当快慢指针相遇时：

• 慢指针走了a + b步
• 快指针走了a + b + kL步（k为圈数）

由于快指针速度是慢指针的2倍：

2(a + b) = a + b + kL => a + b = kL => a = kL - b => a = (k-1)L + (L - b) => a = (k-1)L + c

这表明：从头到入口的距离 = 从相遇点到入口的距离 + 整数圈环长

因此，当两个指针分别从头和相遇点以相同速度出发时，它们必然在入口相遇。

Q2：如果环很大，快指针会不会永远追不上慢指针？

答：不会！这是Floyd算法的数学保证。

在环内，快指针相对慢指针的速度是1步/轮。无论环多大，快指针最多L轮（L为环长）后就会追上慢指针。

具体来说：

• 当慢指针进入环时，快指针已经在环内某位置
• 两者在环内的最大距离为L-1
• 由于相对速度为1，最多L-1轮后相遇

Q3：为什么不能直接返回快慢指针的相遇点作为入口？

答：因为相遇点通常不是入口！

考虑示例1：[3,2,0,-4], pos=1

• 入口是节点2（索引1）
• 但快慢指针相遇在节点-4（索引3）

只有在特殊情况下（如整个链表都是环），相遇点才可能是入口。一般情况下，相遇点和入口是不同的节点。

Q4：算法对环的大小有要求吗？比如环长度为1的情况？

答：算法对任何环大小都适用，包括环长度为1的情况。

环长度为1的例子：[1,2], pos=1（2→2）

• 第一阶段：slow=1→2, fast=1→2→2，相遇在2
• 第二阶段：ptr=1, slow=2；ptr=2, slow=2，返回2（正确入口）

环长度为2的例子：[1,2,3], pos=1（3→2）

• 结构：1→2→3→2→3→…
• 入口是2
• 算法会正确找到入口2

八、优化思路

1. 边界条件优化

提前处理明显的无环情况：

// 已在推荐解法中实现if(head==null){returnnull;}// 可进一步优化if(head.next==null){returnnull;}

2. 循环结构优化

将检测和定位分离，提高代码可读性：

publicListNodedetectCycle(ListNodehead){ListNodemeetingPoint=findMeetingPoint(head);if(meetingPoint==null){returnnull;}returnfindEntry(head,meetingPoint);}privateListNodefindMeetingPoint(ListNodehead){ListNodeslow=head,fast=head;while(fast!=null&&fast.next!=null){slow=slow.next;fast=fast.next.next;if(slow==fast){returnslow;}}returnnull;}privateListNodefindEntry(ListNodehead,ListNodemeetingPoint){ListNodeptr=head;while(ptr!=meetingPoint){ptr=ptr.next;meetingPoint=meetingPoint.next;}returnptr;}

这种写法更清晰，便于测试和维护。

3. 性能微优化

避免重复的空指针检查：

// 原始版本已经很优化，无需进一步改动// 重点在于算法本身的效率，而非微优化

✅结论：快慢指针解法已是理论最优，重点在于正确实现而非微优化。

九、数据结构与算法基础知识点回顾

1. 单链表特性

• 线性结构：每个节点包含数据和指向下一个节点的指针
• 动态分配：内存非连续，插入/删除O(1)（已知位置）
• 访问限制：随机访问O(n)，只能顺序遍历

2. 哈希表（HashSet）

• 底层实现：数组 + 链表/红黑树（Java 8+）
• 时间复杂度：平均O(1)查找/插入
• 空间开销：需要存储所有元素的引用和哈希桶
• 哈希冲突：相同哈希值的不同对象存储在同一桶中

3. Floyd判圈算法

• 发明者：Robert W. Floyd（1967年）
• 别名：龟兔赛跑算法（Tortoise and Hare Algorithm）
• 核心思想：利用速度差在环内必然相遇
• 数学基础：模运算、线性同余、周期性检测

4. 指针操作技巧

• 空指针检查：访问next前必须检查当前节点非null
• 引用比较：使用==比较对象引用，而非equals()比较值
• 边界处理：空链表、单节点、两节点等特殊情况

5. 复杂度分析要点

• 时间复杂度：关注最坏情况下的操作次数
• 空间复杂度：
  • 迭代：只计算显式声明的变量
  • 递归：必须考虑调用栈的深度
• 实际性能：常数因子、缓存局部性、分支预测等因素

6. 数学推导能力

• 代数变换：从已知条件推导未知关系
• 几何直观：将抽象问题转化为图形理解
• 归纳思维：从特殊情况推广到一般情况

十、面试官提问环节

❓ 面试官：请详细解释一下Floyd算法中a = (n-1)L + c这个等式的含义。

考察点：数学推导理解和算法本质把握

回答：
这个等式是Floyd算法的核心，让我用直观的方式解释：

想象你在跑道上跑步：

• 你从起点A开始，跑到环的入口C（距离a）
• 然后在环内继续跑，直到在点E遇到你的朋友（距离b）
• 你的朋友比你跑得快，已经在环内跑了n圈

现在，如果你从起点A重新开始跑，而你的朋友从相遇点E开始跑，你们都以相同的速度跑，会发生什么？

根据等式a = (n-1)L + c：

• 你跑的距离a
• 等于朋友跑的距离c（从E到C）加上(n-1)圈完整环长

这意味着你们会在入口C相遇！

实际意义：

• 这个等式建立了线性距离和环形距离之间的桥梁
• 它告诉我们，虽然我们不知道具体的a、b、c值，但它们之间存在确定的数学关系
• 正是这个关系让我们能够用O(1)空间找到入口

❓ 面试官：如果要求同时返回环的长度，你会怎么修改算法？

考察点：算法扩展能力和问题变种处理

回答：
在找到入口后，我们可以很容易地计算环的长度：

publicintgetCycleLength(ListNodehead){ListNodeentry=detectCycle(head);if(entry==null){return0;// 无环}intlength=1;ListNodecurrent=entry.next;while(current!=entry){length++;current=current.next;}returnlength;}

或者，在Floyd算法的第一阶段就可以计算环长：

publicListNodedetectCycleWithLength(ListNodehead){if(head==null)returnnull;ListNodeslow=head,fast=head;while(fast!=null&&fast.next!=null){slow=slow.next;fast=fast.next.next;if(slow==fast){// 计算环长intcycleLength=1;ListNodetemp=slow.next;while(temp!=slow){cycleLength++;temp=temp.next;}// 找入口ListNodeptr=head;while(ptr!=slow){ptr=ptr.next;slow=slow.next;}returnptr;}}returnnull;}

时间复杂度：仍然是O(n)，因为计算环长最多需要L步（L ≤ n）
空间复杂度：仍然是O(1)

❓ 面试官：你的算法中，为什么快指针要检查fast.next != null而不是只检查fast != null？

考察点：边界条件处理和空指针防护意识

回答：
这是一个非常重要的安全防护措施。

因为快指针每次要走两步（fast.next.next），所以在执行这步操作前，必须确保：

1. fast != null（当前节点存在）
2. fast.next != null（下一个节点存在）

如果只检查fast != null，当fast指向倒数第二个节点时：

• fast不为null
• 但fast.next是最后一个节点
• fast.next.next就是null.next，会导致NullPointerException

通过双重检查fast != null && fast.next != null，我们确保了：

• 快指针至少还有两个节点可以走
• 避免了所有可能的空指针异常
• 代码在各种边界情况下都能安全运行

这体现了良好的编程习惯和对边界条件的充分考虑。

❓ 面试官：能否用这个算法解决"寻找重复数II"的问题？

考察点：知识迁移和抽象建模能力

回答：
当然可以！这正是Floyd判圈算法的经典应用场景。

问题：给定一个包含n+1个整数的数组nums，其数字都在[1, n]范围内。假设只有一个重复的数字，但可能重复多次，找出这个重复的数字。

转换思路：

• 将数组看作函数f(i) = nums[i]
• 从索引0开始，序列0 → nums[0] → nums[nums[0]] → …
• 由于存在重复数字，这个序列必然形成环
• 环的入口就是重复的数字

publicintfindDuplicate(int[]nums){// 第一阶段：找相遇点intslow=nums[0];intfast=nums[0];do{slow=nums[slow];fast=nums[nums[fast]];}while(slow!=fast);// 第二阶段：找入口（重复数字）intptr=nums[0];while(ptr!=slow){ptr=nums[ptr];slow=nums[slow];}returnptr;}

为什么入口是重复数字？

• 重复数字意味着有两个不同的索引i和j，使得nums[i] = nums[j] = x
• 这导致序列中x有两个前驱，形成了环
• 环的入口就是x，即重复的数字

这种方法时间复杂度O(n)，空间复杂度O(1)，完美解决了约束条件。

十一、这道算法题在实际开发中的应用

1. 内存泄漏检测

• 循环引用检测：在垃圾回收器中识别对象间的循环引用
• 智能指针管理：C++的weak_ptr用于打破shared_ptr的循环引用
• DOM内存分析：浏览器开发者工具检测HTML文档中的循环引用

2. 数据库系统

• 死锁检测：事务等待图中的环表示死锁，入口节点表示死锁起始点
• 外键约束验证：检测表间引用关系中的循环依赖
• 查询优化：识别SQL查询中的循环引用模式

3. 编译器与解释器

• 语法分析：检测语法产生式中的左递归（形成环）
• 类型系统：识别类型定义中的循环依赖
• 控制流分析：找到程序中的循环入口点，用于优化

4. 网络与分布式系统

• 路由环路检测：网络协议中检测数据包的循环转发路径
• 分布式一致性：检测共识算法中的循环依赖
• 服务发现：识别微服务调用链中的循环依赖

5. 游戏开发

• AI行为树：检测决策树中的无限循环模式
• 物理引擎：约束求解器中的循环依赖检测
• 关卡验证：确保游戏关卡的可达性和无死循环

6. 生物信息学

• 基因调控网络：识别调控关系中的反馈环入口
• 代谢通路分析：找到生物化学反应循环的起始点
• 蛋白质折叠：检测结构中的循环模式

💡核心价值：环入口检测不仅是算法题，更是系统诊断和优化的关键工具。掌握它，就掌握了识别和解决各种"循环依赖"问题的能力。

十二、相关题目推荐

🔗学习路径建议：

1. 先掌握[141. 环形链表]的基础检测
2. 深入理解本题的Floyd算法数学推导
3. 应用到[287. 寻找重复数]，掌握算法通用性
4. 练习其他链表题目，巩固指针操作技巧

十三、总结与延伸

核心收获

1. Floyd判圈算法精髓：不仅检测环，还能精确定位入口
2. 数学推导能力：从物理直觉到严格数学证明的思维转换
3. 空间复杂度意识：O(1)空间解法在实际工程中的巨大价值
4. 算法通用性：同一算法框架可应用于不同数据结构和问题域

延伸思考

• 多环检测：如果链表中有多个环，如何处理？（实际上单链表最多一个环）
• 概率算法：能否用随机采样近似找到入口？（可以，但有误差）
• 动态环检测：链表在运行时动态变化，如何实时维护入口信息？
• 并行化可能：能否用多线程加速环检测？（本质上是顺序依赖，难以并行）

最终建议

• 面试必备：必须能手写快慢指针解法，包括完整的数学解释
• 深入理解：不仅要会写代码，还要能推导和解释数学关系
• 举一反三：掌握Floyd算法的思想，能解决各种"循环检测"问题
• 工程实践：在实际项目中，优先选择空间高效的解决方案

结语：环形链表 II 是算法面试的经典难题，它完美融合了数学推导、指针操作和空间优化。从哈希表的直观到Floyd算法的精妙，每一步都体现了算法设计的艺术。掌握它，你不仅解决了一道题，更获得了解决"循环结构分析"类问题的通用思维框架，这在系统设计和性能优化中具有不可估量的价值！