【算法专题训练】15、环形链表

原创已于 2025-08-21 10:35:49 修改 · 348 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #链表 #linux #c++

于 2025-08-21 10:35:06 首次发布

算法专栏收录该内容

26 篇文章

订阅专栏

1、LCR 022. 环形链表 II

题目信息：

https://leetcode.cn/problems/c32eOV/description/

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。
如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，
则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。

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

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

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

提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

解题思路：

链表带环，是指链表尾部的下一个指针指向链表中的某个节点，而不是指向空
输入一个链表头结点，判断该链表是否存在环，如果存在环则返回进入环的第一个节点，没有环则返回null；
先判断链表是否存在环,通过快慢指针解决，只要链表存在环，则快慢指针一定会相遇。
那如何找到进入环的结点位置呢？
先求出环的个数，通过遍历环中相遇的结点来计算环的总结点个数n
则链表的总个数-减去环的结点个数，就是前面结点的个数，前面结点移动的个数位置就是环的入口结点
继续使用双指针，前一个指针先移动环个数n个位置，然后让后指针从头结点开始移动，两个指针相遇的结点位置就是环的入口结点

代码实现

// 返回链表环中相遇的结点，没有环则返回null
ListNode *getLoopNode(ListNode *head)
{
    if (head == nullptr)
    {
        return nullptr;
    }
    ListNode *fast = head->next;
    ListNode *slow = head;

    while (fast != nullptr && slow != nullptr)
    {
        std::cout << "fast:" << fast->val << std::endl;
        std::cout << "slow:" << slow->val << std::endl;
        if (fast == slow)
        {
            return slow;
        }
        slow = slow->next;
        fast = fast->next;
        if (fast != nullptr)
        {
            fast = fast->next;
        }
    }
    return nullptr;
}

ListNode *detectCycle(ListNode *head)
{
    if (head == nullptr)
    {
        return nullptr;
    }

    ListNode *loopNode = getLoopNode(head);
    std::cout << "loopNode:" << loopNode->val << std::endl;
    if (loopNode == nullptr)
    {
        return nullptr;
    }

    // 计算环的结点个数
    int count = 1;
    ListNode *tempNode = loopNode->next;
    while (tempNode != loopNode)
    {
        tempNode = tempNode->next;
        count++;
    }
    std::cout << "loopNode count:" << count << std::endl;

    // 定义双指针，让pre指针先移动count位置
    ListNode *fast = head;
    ListNode *slow = head;
    for (int i = 0; i < count; i++)
    {
        fast = fast->next;
    }

    while (fast != slow)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

2、LCR 023. 相交链表

题目信息：

https://leetcode.cn/problems/3u1WK4/description/

给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：
listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]
进阶：能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

解题思路：

审题：输入两个链表，判断两个链表是否相连，如果相连则返回相交的结点，否则返回null
将问题转化为环形链表的入口点，和LCR22题一样了，将链表a的首尾结点相连
操作链表b，从链表b的头结点开始遍历，如果链表a和b相交的话，则链表b一定存在环情况，
使用快慢指针找到环中相遇的结点，遍历环中结点，找到环的个数count
根据环的个数，继续使用双指针，让快指针先移动count，然后让慢指针开始移动，直到快慢指针相遇，此时的结点即为相交节点
返回该相交节点，返回前需要将之前的链表b断开，恢复原样

代码实现：

ListNode *findLoopNode(ListNode *head)
{
    if (head == nullptr)
    {
        return nullptr;
    }
    ListNode *fast = head->next;
    ListNode *slow = head;

    while (fast != nullptr && slow != nullptr)
    {
        if (fast == slow)
        {
            return slow;
        }
        slow = slow->next;
        fast = fast->next;
        if (fast != nullptr)
        {
            fast = fast->next;
        }
    }
    return nullptr;
}

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
{
    if (headA == nullptr || headB == nullptr) // 过滤空链表
    {
        return nullptr;
    }

    // 1、找到链表a的尾节点
    ListNode *tailNode = headA;
    while (tailNode->next != nullptr)
    {
        tailNode = tailNode->next;
    }

    std::cout << "tailNode.val:" << tailNode->val << std::endl;
    // 2、将链表a，的头尾节点相连
    tailNode->next = headA;

    // 3、判断链表b是否存在环
    ListNode *loopNode = findLoopNode(headB);

    std::cout << "loopNode.val:" << loopNode->val << std::endl;
    if (loopNode == nullptr)
    { // 不存在环，说明链表a，b不相交
        tailNode->next = nullptr;
        return nullptr;
    }

    // 4、找到链表中环的结点个数
    int nodeCount = 1;
    ListNode *tempNode = loopNode->next;
    std::cout << "tempNode.val:" << tempNode->val << std::endl;
    while (tempNode != loopNode)
    {
        tempNode = tempNode->next;
        nodeCount++;
    }
    std::cout << "nodeCount:" << nodeCount << std::endl;
    std::cout << "headB.val:" << headB->val << std::endl;

    // 5、使用快慢指针，查找链表b环的入口结点
    ListNode *fast = headB;
    ListNode *slow = headB;
    for (int i = 0; i < nodeCount; i++)
    {
        fast = fast->next;
    }
    std::cout << "fast.val:" << fast->val << std::endl;
    std::cout << "slow.val:" << slow->val << std::endl;

    // 快慢指针同时移动，直到相遇
    while (fast != slow)
    {
        fast = fast->next;
        slow = slow->next;
    }

    tailNode->next = nullptr;
    return slow;
}