目录
[❌ 第一种直接想法（失败）：我们是不是能"记住走过的节点"？](#❌ 第一种直接想法（失败）：我们是不是能“记住走过的节点”？)
初始思考：什么叫"链表有环"？
链表的本质是：
Node → Node → Node → NULL但如果链表中某个节点的 next 指针不是 NULL，而是指向之前的某个节点：
Node → Node → Node
↑ ↓
←←←←←←←←←←这就变成了一个"环形结构"。
❓我们怎么知道某个链表有没有环？
你无法一次看完所有节点。你只能从头开始，一个一个往后走：
cpp
while (p != NULL) {
p = p->next;
}正常情况下你最终会走到 p == NULL
但是如果链表有环，你会一直绕圈，永远也走不到 NULL，程序变成死循环。
❌ 第一种直接想法（失败）：我们是不是能"记住走过的节点"？
想法：
每访问一个节点，就记住它；
如果某个节点我们第二次看到，就说明有环。
这个思路需要什么？
需要能"记住所有走过的节点"，并判断是否"已经访问过"
⚠️ 但我们没有 STL、没有哈希表、没有额外空间！
所以这个方法不符合第一性原则的最低资源要求，我们暂时排除。
那我们换一个思路：我们能否只用两个指针来检测环？
想象一下：
如果你在一个环形跑道上，有两个人：
一个人慢跑（每次走一步）
一个人快跑（每次走两步）
如果跑道没有环，快跑的人会直接跑出终点。
如果跑道是环形的，快跑的人迟早会"追上"慢跑的人！
这就是 Floyd's Cycle Detection Algorithm（龟兔赛跑法）
我们现在从零构建它！
第一步：定义两个指针
cpp
slow = head;
fast = head;-
slow每次走一步：slow = slow->next -
fast每次走两步：fast = fast->next->next
这一步是算法核心，"快指针"在追"慢指针"
第二步：建立循环
| 变量 | 含义 |
|---|---|
| slow | 模拟"正常访问"的一步步访问 |
| fast | 模拟"追赶检测"的两步步访问 |
| slow==fast | 表示 fast 追上 slow，说明有环 |
| fast==NULL | 表示链表已经结束，无环 |
问题：我们什么时候会出错？
-
如果
fast == NULL：说明走到尾部 -
如果
fast->next == NULL：再走一步就越界
我们必须确保两个指针不越界（避免访问 NULL 的 next）：
cpp
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
// 二者相遇，说明有环
}
}❓为什么 slow 和 fast 相遇就说明有环？
因为只有在环中，快指针才有可能"绕回来追上慢指针"
就像操场上，跑得快的人终将追上慢跑的那个人。
如果没有环，fast 最终会变成 NULL 或 fast->next == NULL，循环终止。
如果链表中有环，两个指针最终会在环中某处相遇：
cpp
if (slow == fast)
return 1; // 有环空链表或一个节点链表怎么办？
-
如果
head == NULL：直接退出循环，返回 0 ✅ -
如果只有一个节点：
fast->next == NULL，也会直接退出 ✅
完整代码
cpp
int hasLoop(struct Node* head) {
struct Node* slow = head;
struct Node* fast = head;
// Step 1: 同时从头开始，每次走一步和两步
while (fast != NULL && fast->next != NULL) {
slow = slow->next; // 慢指针走一步
fast = fast->next->next; // 快指针走两步
if (slow == fast) // 相遇 → 有环
return 1;
}
// Step 2: 如果快指针走到了链表尾部，说明无环
return 0;
}时间 & 空间复杂度分析
| 复杂度 | 说明 |
|---|---|
| 时间复杂度 | O(n)，最坏情况 fast 会走到链表尽头（或追上 slow） |
| 空间复杂度 | O(1)，只用了两个指针变量，无需额外空间 |
我们从"什么都不会"出发，只知道我们：
-
只能走
->next -
不允许记录历史
-
想办法"检测重复访问"
最终我们想到"相遇 → 有环"的思路，从而构建出用两个指针的检测算法。