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

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

一、原题回顾

题目编号：LeetCode 141
题目名称：环形链表（Linked List Cycle）
难度等级：简单（Easy）但极具代表性

题目描述

给你一个链表的头节点head，判断链表中是否有环。

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

注意：评测系统使用整数pos来表示链表尾连接到链表中的位置（索引从0开始），但pos不作为参数传递。

如果链表中存在环，返回true；否则，返回false。

示例说明

示例 1：

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

图示：

3 → 2 → 0 → -4 ↑_________↓

示例 2：

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

图示：

1 → 2 ↑___↓

示例 3：

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

约束条件

链表中节点的数目范围是[0, 10⁴]
-10⁵ <= Node.val <= 10⁵
pos为-1或者链表中的一个有效索引
进阶要求：使用 O(1) 常量内存解决此问题

节点定义

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

二、原题分析

环形链表检测是链表操作的基础问题，核心挑战在于如何在有限资源下检测循环：

🔑 关键洞察

循环本质：存在节点被多次访问，形成闭合路径
访问限制：单链表只能向前遍历，无法直接判断是否重复访问
内存约束：进阶要求O(1)空间，排除了简单的记录访问历史方案
终止条件：无环链表以null结尾，有环链表无限循环

🎯 解题目标

在满足时间O(n)、空间O(1)的前提下，高效判断链表是否存在环。

❌ 常见误区

误区1：比较节点值 → 错误！可能有重复值但无环
误区2：计数访问次数 → 无法确定何时停止（有环时无限循环）
误区3：修改节点标记 → 破坏原始数据结构，不符合工程实践

三、答案构思

我们将构建两种主要解法，体现不同的算法思维：

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

思路：记录已访问的节点，检测重复访问
优点：直观易懂，代码简单
缺点：空间复杂度O(n)，不满足进阶要求

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

思路：利用速度差在环内必然相遇的数学原理
优点：空间复杂度O(1)，满足进阶要求
缺点：需要理解算法原理，初始条件设置需谨慎

下面详细展开两种方法。

四、完整答案（Java 实现）

方法一：哈希表

importjava.util.HashSet;importjava.util.Set;publicclassSolution{publicbooleanhasCycle(ListNodehead){// 边界情况：空链表或单节点无环if(head==null){returnfalse;}Set<ListNode>visited=newHashSet<>();ListNodecurrent=head;while(current!=null){// 如果当前节点已访问过，说明存在环if(!visited.add(current)){returntrue;}current=current.next;}returnfalse;// 到达null，无环}}

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

publicclassSolution{publicbooleanhasCycle(ListNodehead){// 边界情况：空链表或单节点无环if(head==null||head.next==null){returnfalse;}// 初始化快慢指针ListNodeslow=head;// 慢指针，每次走1步ListNodefast=head.next;// 快指针，每次走2步// 当快慢指针未相遇时继续while(slow!=fast){// 快指针到达末尾，说明无环if(fast==null||fast.next==null){returnfalse;}slow=slow.next;// 慢指针走1步fast=fast.next.next;// 快指针走2步}returntrue;// 快慢指针相遇，说明有环}}

💡替代实现（使用do-while循环）：

publicbooleanhasCycle(ListNodehead){if(head==null||head.next==null){returnfalse;}ListNodeslow=head;ListNodefast=head;do{slow=slow.next;fast=fast.next.next;if(fast==null||fast.next==null){returnfalse;}}while(slow!=fast);returntrue;}

五、代码分析

方法一：哈希表

执行流程：

创建HashSet存储已访问的节点引用
遍历链表，对每个节点：
- 尝试添加到Set中
- 如果添加失败（返回false），说明已存在，返回true
如果遍历到null，返回false

优点：

逻辑清晰：符合直觉，易于理解和调试
早期检测：一旦发现重复立即返回
通用性强：适用于任何可哈希的对象

缺点：

空间开销大：最坏情况下存储所有n个节点
哈希冲突：虽然Java的HashSet处理良好，但理论上存在
对象相等性：依赖ListNode的equals()和hashCode()实现

关键细节：

使用Set.add()的返回值：成功添加返回true，已存在返回false
比较的是节点引用而非值，确保正确性

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

数学原理：

设环的长度为L，慢指针进入环时，快指针已在环内某位置
快指针相对慢指针的速度为1步/轮
无论初始距离是多少，快指针最多L轮后追上慢指针

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

轮次	slow	fast	说明
初始	3	2	slow=head, fast=head.next
1	2	0	slow=2, fast=0
2	0	2	slow=0, fast=2 (fast.next.next = -4→2)
3	2	0	slow=2, fast=0
4	0	2	slow=0, fast=2
…	…	…	进入循环

等等，这里有问题！让我们重新计算：

实际上，在示例1中：

链表结构：3→2→0→-4→2（回到索引1）
初始：slow=3, fast=2
轮次1：slow=2, fast=0（2→0→-4，但fast走两步：2→0→-4？不对）

正确计算：

初始：slow=3, fast=2
轮次1：slow=2, fast=-4（fast: 2→0→-4）
轮次2：slow=0, fast=0（fast: -4→2→0）
相遇！返回true

优点：

空间最优：仅使用两个指针变量
时间高效：最多2n次操作
无副作用：不修改原链表，不依赖额外数据结构

关键细节：

初始条件：slow=head, fast=head.next（配合while循环）
终止条件：fast==null || fast.next==null（防止空指针异常）
相遇判断：slow==fast（引用相等）

⚠️为什么fast初始化为head.next？
如果都初始化为head，while(slow != fast)条件不满足，循环不会执行。
初始化为head和head.next，确保至少执行一次循环，或者使用do-while。

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

方法	时间复杂度	空间复杂度	说明
哈希表	O(n)	O(n)	存储所有节点引用
快慢指针	O(n)	O(1)	两个指针，常数空间

详细推导（快慢指针）

无环情况：

快指针每轮走2步，慢指针每轮走1步
快指针先到达末尾（null）
总操作次数：约2n（快指针走完n个节点）

有环情况：

设链表非环部分长度为a，环长度为b
慢指针进入环需要a步
此时快指针已在环内，距离慢指针最多b-1步
快指针相对速度为1步/轮，最多b轮后相遇
总操作次数：a + b ≤ n

空间复杂度：

仅使用slow和fast两个指针变量
无递归调用栈
总计：O(1)

📊性能对比（n=10000）：
哈希表：10000次操作 + 10000个对象存储 + 哈希计算开销
快慢指针：≤20000次操作 + 2个指针变量
在内存受限环境（如嵌入式系统），快慢指针优势明显！

七、问题解答（FAQ）

Q1：为什么快慢指针一定能在环内相遇？

答：这是Floyd判圈算法的核心数学保证：

设环的长度为L，当慢指针进入环时，快指针已经在环内某位置，两者距离为d（0 ≤ d < L）。

每轮操作后，快指针相对慢指针前进1步
经过d轮后，快指针正好追上慢指针
因为d < L ≤ n，所以最多n轮内必然相遇

这类似于跑道上的追赶问题：速度快的选手最终会套圈速度慢的选手。

Q2：能否让快指针每次走3步或更多？

答：理论上可以，但不推荐：

走3步：相对速度为2步/轮，仍然能相遇
问题：可能跳过相遇点，需要更复杂的终止条件
边界情况：当环长度为2时，快指针可能永远与慢指针错开

标准的2步方案经过数学证明是最可靠和高效的。

Q3：如果链表很大（如10⁶节点），哈希表方法会怎样？

答：会出现严重的内存问题：

内存消耗：10⁶个ListNode引用，约8MB（64位系统）
GC压力：大量临时对象增加垃圾回收负担
哈希性能：大量对象可能导致哈希冲突，影响性能

而快慢指针方法不受数据规模影响，始终保持O(1)空间。

Q4：为什么不能通过节点值判断环？

答：因为值重复 ≠ 环存在：

// 反例：无环但值重复1→2→1→3→null

这个链表没有环，但值1出现了两次。只有同一个节点对象被多次访问才构成环。

这就是为什么必须比较节点引用（内存地址），而不是节点值。

八、优化思路

1. 边界条件优化

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

// 已在推荐解法中实现if(head==null||head.next==null){returnfalse;}

2. 循环条件优化

使用do-while避免初始条件的特殊处理：

publicbooleanhasCycle(ListNodehead){if(head==null||head.next==null){returnfalse;}ListNodeslow=head;ListNodefast=head;do{slow=slow.next;fast=fast.next.next;if(fast==null||fast.next==null){returnfalse;}}while(slow!=fast);returntrue;}

这种写法更符合"龟兔同起点"的直观理解。

3. 并行化思考

环检测本质上是顺序依赖的操作，无法并行化。这是链表数据结构的固有特性。

✅结论：快慢指针已是理论最优解，无需进一步优化。

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

1. 单链表基础

线性结构：每个节点包含数据和指向下一个节点的指针
动态性：内存非连续分配，插入/删除O(1)（已知位置）
局限性：只能单向遍历，访问第k个元素需O(k)时间

2. 哈希表（HashSet）

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

3. Floyd判圈算法

发明者：Robert W. Floyd（1967年）
别名：龟兔赛跑算法（Tortoise and Hare Algorithm）
应用场景：
- 链表环检测
- 寻找重复数（数组版本）
- Pollard’s rho算法（因式分解）
数学基础：模运算和周期性检测

4. 指针操作技巧

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

5. 复杂度分析要点

时间复杂度：关注最坏情况下的操作次数
空间复杂度：
- 迭代：只计算显式声明的变量
- 递归：必须考虑调用栈的深度
实际性能：常数因子和缓存局部性也很重要

6. 内存管理

对象引用：Java中变量存储的是对象引用（类似指针）
垃圾回收：断开引用后，对象可能被GC回收
内存安全：正确的指针操作避免内存泄漏和悬空指针

十、面试官提问环节

❓ 面试官：你更推荐哪种解法？为什么？

考察点：工程实践意识和算法选择能力

回答：
在生产环境中，我强烈推荐快慢指针解法，原因如下：

空间效率：O(1)空间复杂度，不会因数据量大而导致内存问题
性能稳定：没有哈希计算开销，执行速度更快且可预测
无依赖：不依赖额外的数据结构，代码更简洁可靠
工程友好：满足进阶要求，体现了对算法优化的理解

哈希表方法虽然直观，但在处理大规模数据时存在明显的内存瓶颈，不符合"用最少资源解决问题"的工程原则。

❓ 面试官：如果要求找到环的入口节点，你会怎么做？

考察点：知识延伸和问题变种处理能力

回答：
这是LeetCode第142题「环形链表 II」，可以在快慢指针基础上扩展：

算法步骤：

使用快慢指针检测环的存在
当快慢指针相遇时，将一个指针重置到head
两个指针都以相同速度（每次1步）移动
再次相遇的节点就是环的入口

数学证明：

设非环部分长度为a，环长度为b
相遇时，慢指针走了a + c步，快指针走了a + c + kb步（k为圈数）
由于快指针速度是慢指针的2倍：2(a + c) = a + c + kb
得到：a + c = kb → a = kb - c
这意味着从head到入口的距离a，等于从相遇点绕环kb - c步的距离

publicListNodedetectCycle(ListNodehead){if(head==null||head.next==null)returnnull;ListNodeslow=head,fast=head;// 检测环while(fast!=null&&fast.next!=null){slow=slow.next;fast=fast.next.next;if(slow==fast)break;}// 无环if(fast==null||fast.next==null)returnnull;// 找入口slow=head;while(slow!=fast){slow=slow.next;fast=fast.next;}returnslow;}

❓ 面试官：你的快慢指针解法中，为什么快指针要检查fast.next != null？

考察点：边界条件和空指针处理

回答：
这是一个非常重要的空指针防护措施。

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

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

如果只检查fast != null，当fast指向最后一个节点时，fast.next为null，再访问fast.next.next会导致NullPointerException。

这种双重检查确保了程序的健壮性，是处理链表问题的基本功。

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

考察点：知识迁移和抽象思维能力

回答：
完全可以！这是Floyd判圈算法的经典应用之一。

问题：给定一个包含n+1个整数的数组nums，其数字都在[1, n]范围内，证明至少存在一个重复的数字。假设只有一个重复的数字，找出它。

转换思路：

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

publicintfindDuplicate(int[]nums){// 找环intslow=nums[0],fast=nums[0];do{slow=nums[slow];fast=nums[nums[fast]];}while(slow!=fast);// 找入口slow=nums[0];while(slow!=fast){slow=nums[slow];fast=nums[fast];}returnslow;}

这种方法时间复杂度O(n)，空间复杂度O(1)，完美解决了不能修改数组且不能使用额外空间的约束。

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

1. 内存泄漏检测

循环引用：在垃圾回收器中检测对象间的循环引用
智能指针：C++的shared_ptr需要检测循环引用避免内存泄漏
DOM树遍历：浏览器需要检测HTML文档中的循环引用

2. 数据库事务处理

死锁检测：事务等待图中的环表示死锁
依赖分析：包依赖关系中的环表示循环依赖
版本控制：Git的提交历史中检测异常的循环引用

3. 编译器优化

控制流图：检测程序中的无限循环
数据流分析：识别不可达代码和死循环
寄存器分配：活变量分析中的循环检测

4. 网络协议

路由环路：网络路由协议中的环路检测
数据包追踪：检测数据包在网络中的循环转发
分布式系统：一致性协议中的环检测

5. 游戏开发

AI行为树：检测AI决策树中的无限循环
关卡设计：验证游戏关卡的可达性和无环性
物理引擎：约束求解中的循环依赖检测

6. 生物信息学

基因调控网络：检测基因表达调控中的反馈环
蛋白质相互作用：分析蛋白质网络中的循环模式
代谢通路：识别生物化学反应中的循环路径

💡核心价值：环检测不仅是算法题，更是系统稳定性保障的基础工具。掌握高效的环检测算法，能够在各种实际场景中快速识别和处理潜在的无限循环问题。

十二、相关题目推荐

题号	题目	关联点
141. 环形链表	本题	环存在性检测
142. 环形链表 II	找环入口	Floyd算法进阶
287. 寻找重复数	数组环检测	Floyd算法应用
202. 快乐数	数字环检测	类似思想
206. 反转链表	链表基础	指针操作练习
876. 链表的中间结点	快慢指针	基础应用