环形链表检测：哈希表与快慢指针算法详解

匹夫无不报之仇

1. 环形链表检测问题概述

判断链表是否有环是数据结构与算法中的经典问题，也是技术面试中的高频考点。这个问题的核心在于如何高效地检测链表中是否存在循环引用。在实际开发中，环形链表的检测对于内存管理、死锁预防等场景都有重要意义。

链表与数组不同，它通过指针将零散的内存块串联起来。每个节点包含数据域和指针域，指针域存储下一个节点的地址。正常情况下，链表最后一个节点的指针指向null，表示链表结束。但如果某个节点的指针指向了之前的某个节点，就形成了环。

举个例子，想象你在公园里跑步。正常情况下你会沿着跑道跑完一圈后停下来（相当于链表以null结束）。但如果跑道被设计成了莫比乌斯环，你就会一直循环跑下去（相当于链表形成了环）。我们的算法就是要检测这种"无限循环"的情况。

2. 哈希表解法详解

2.1 基本思路与实现

哈希表法是解决环形链表检测问题最直观的方法。其核心思想是：在遍历链表的过程中，记录所有已经访问过的节点。如果遇到一个节点已经被记录过，就说明链表有环。

java复制public boolean hasCycle(ListNode head) {
    Set<ListNode> visited = new HashSet<>();
    ListNode current = head;
    
    while (current != null) {
        if (visited.contains(current)) {
            return true;
        }
        visited.add(current);
        current = current.next;
    }
    return false;
}

这个实现中，我们使用HashSet来存储已经访问过的节点。时间复杂度是O(n)，因为每个节点最多被访问一次；空间复杂度也是O(n)，因为最坏情况下需要存储所有节点。

2.2 性能分析与优化

虽然哈希表法思路简单，但在实际应用中存在几个问题：

空间开销大：需要额外O(n)的空间存储节点
哈希冲突：当链表很长时，哈希表的性能可能下降
节点比较：依赖节点的内存地址而非值进行比较

提示：在Java中，HashSet的contains和add操作平均时间复杂度是O(1)，但最坏情况下可能退化到O(n)。不过对于链表检测问题，这种情况很少见。

2.3 适用场景

哈希表法适合以下场景：

需要保留访问历史记录的情况
链表长度不大，空间开销可接受
作为教学示例，帮助理解问题本质

3. 快慢指针法深入解析

3.1 算法原理与数学证明

快慢指针法（又称Floyd判圈算法）是解决环形链表检测问题的最优解。它使用两个指针，一个每次移动一步（慢指针），一个每次移动两步（快指针）。如果链表有环，快指针最终会追上慢指针。

数学证明：
设环的长度为L，快慢指针进入环时的距离差为d（0 ≤ d < L）。每次移动后，快指针比慢指针多走一步，因此最多经过L次移动后，快指针必然追上慢指针。

3.2 标准实现与边界处理

java复制public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    
    ListNode slow = head;
    ListNode fast = head.next;
    
    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}

这个实现有几个关键点：

初始时快指针比慢指针领先一步，避免立即相等
每次移动后检查快指针是否到达终点（null）
当快慢指针相遇时返回true

3.3 变体实现与比较

另一种常见的初始化方式是让快慢指针都从head开始：

java复制public boolean hasCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;
    
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) {
            return true;
        }
    }
    return false;
}

这种实现的优点是：

代码更简洁
不需要特殊处理head.next为null的情况
更符合直觉，容易理解

3.4 性能特点

快慢指针法的优势在于：

时间复杂度：O(n)（线性时间）
空间复杂度：O(1)（常数空间）
不需要额外数据结构
不会修改原始链表

4. 其他解法探讨

4.1 节点标记法

节点标记法通过修改链表节点的值来标记已经访问过的节点：

java复制public boolean hasCycle(ListNode head) {
    ListNode current = head;
    while (current != null) {
        if (current.val == Integer.MAX_VALUE) {
            return true;
        }
        current.val = Integer.MAX_VALUE;
        current = current.next;
    }
    return false;
}

这种方法虽然空间复杂度是O(1)，但有以下问题：

破坏了原始数据
如果节点值本来就包含标记值会导致误判
不是通用的解决方案

4.2 反转链表法

另一种思路是通过反转链表来检测环：

java复制public boolean hasCycle(ListNode head) {
    ListNode prev = null;
    ListNode current = head;
    ListNode next;
    
    while (current != null) {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
        
        if (current == head) {
            return true; // 回到了起点，说明有环
        }
    }
    return false;
}