算法题环形链表

最新推荐文章于 2025-07-29 19:56:06 发布

一个憨憨coder

最新推荐文章于 2025-07-29 19:56:06 发布

阅读量943

点赞数 21

CC 4.0 BY-SA版权

分类专栏：算法文章标签：算法

本文链接：https://blog.youkuaiyun.com/a1256afafaafr/article/details/148865959

算法专栏收录该内容

127 篇文章

订阅专栏

141. 环形链表

问题描述

给定一个链表，判断链表中是否有环。如果链表中有某个节点可以通过连续跟踪 next 指针再次到达，则链表中存在环。使用整数 pos 表示链表尾连接到链表中的位置（索引从 0 开始），若 pos = -1 则无环。

示例：

输入：head = [3,2,0,-4], pos = 1 → 输出：true（尾部连接到第二个节点）
输入：head = [1,2], pos = 0 → 输出：true（尾部连接到第一个节点）
输入：head = [1], pos = -1 → 输出：false（无环）

算法思路：快慢指针（Floyd 判圈算法）

初始化指针：
- slow 慢指针每次移动 1 步
- fast 快指针每次移动 2 步
遍历链表：
- 当 fast 不为 null 且 fast.next 不为 null 时循环
- 移动指针：slow = slow.next，fast = fast.next.next
判断相遇：
- 若 slow == fast 说明有环
- 若 fast 遇到 null 说明无环

数学证明：

设环外长度 ( a )，环内相遇点距环入口 ( b )，环剩余长度 ( c )（环总长 ( b+c )）
当 slow 走 ( a+b ) 步时，fast 走 ( 2(a+b) ) 步
快慢指针满足：( 2(a+b) = a + b + k(b+c) )（( k ) 为快指针绕环圈数）
化简得：( a = (k-1)(b+c) + c )
该等式恒成立，故必会相遇

代码实现

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        // 边界处理：空链表或单节点无环
        if (head == null || head.next == null) {
            return false;
        }
        
        ListNode slow = head;  // 慢指针（每次1步）
        ListNode fast = head;   // 快指针（每次2步）
        
        // 遍历链表（fast需检查两步）
        while (fast != null && fast.next != null) {
            slow = slow.next;          // 慢指针移动1步
            fast = fast.next.next;     // 快指针移动2步
            
            // 相遇说明有环
            if (slow == fast) {
                return true;
            }
        }
        return false;  // 遍历结束无环
    }
}

算法分析

时间复杂度：( O(n) )
- 无环时：快指针先到达尾部，遍历 ( n/2 ) 次
- 有环时：慢指针入环前走 ( a ) 步，入环后走 ( c ) 步被追上（总步数小于 ( n )）
空间复杂度：( O(1) )
- 仅使用两个指针

关键点

终止条件：
- fast == null（偶数节点无环）
- fast.next == null（奇数节点无环）
指针起点：
- 同起点 head 开始（也可让 slow=head, fast=head.next）
移动顺序：
- 先移动指针再判断相遇（若先判断则初始状态 slow==fast）

算法过程

无环链表：1 → 2 → 3 → null
步骤：
  slow:1 → 2 → 3
  fast:1 → 3 → null（终止）

有环链表：3 → 2 → 0 → -4 → 2（环）
步骤：
  slow:3 → 2 → 0 → -4
  fast:3 → 0 → 2 → -4 → 0 → 2
  在 -4 处未相遇，在 2 处相遇

测试用例

public static void main(String[] args) {
    Solution solution = new Solution();
    
    // 测试用例1：有环（尾部连接位置1）
    ListNode node1 = new ListNode(3);
    ListNode node2 = new ListNode(2);
    ListNode node3 = new ListNode(0);
    ListNode node4 = new ListNode(-4);
    node1.next = node2; node2.next = node3; node3.next = node4; node4.next = node2;
    System.out.println("Test 1: " + solution.hasCycle(node1)); // true
    
    // 测试用例2：有环（尾部连接位置0）
    ListNode node5 = new ListNode(1);
    ListNode node6 = new ListNode(2);
    node5.next = node6; node6.next = node5;
    System.out.println("Test 2: " + solution.hasCycle(node5)); // true
    
    // 测试用例3：无环
    ListNode node7 = new ListNode(1);
    System.out.println("Test 3: " + solution.hasCycle(node7)); // false
    
    // 测试用例4：长链表无环
    ListNode head = new ListNode(0);
    ListNode cur = head;
    for (int i = 1; i <= 1000; i++) {
        cur.next = new ListNode(i);
        cur = cur.next;
    }
    System.out.println("Test 4: " + solution.hasCycle(head)); // false
}

常见问题

为什么快指针走两步？走三步可以吗？
- 走两步必会相遇（速度差为1，能追上）。走三步可能错过（速度差为2，若环长奇数可能永远追不上）。
如何找到环的入口？
- 当快慢指针相遇后，将快指针移回链表头，然后两指针每次各走一步，再次相遇点即为环入口（根据公式 ( a = c ) 推导）。
边界条件处理
- 空链表直接返回 false
- 单节点需检查 next 是否为 null（无环）
为什么先移动指针再判断？
- 若先判断相遇，初始状态 slow 和 fast 都指向 head 会立即返回 true（错误判环）。

142. 环形链表 II

问题描述

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

示例：

输入：head = [3,2,0,-4]，pos = 1（尾部连接到索引1节点）
输出：返回索引为1的节点（值为2）

算法思路：快慢指针 + 数学推导

判断是否有环：
- 快指针（每次2步）和慢指针（每次1步）从起点出发
- 若相遇则说明有环
寻找环入口：
- 相遇后将快指针移回链表头
- 两指针每次各走1步，再次相遇点即为环入口