算法练习-环形链表（思路+流程图+代码）

难度参考

        难度：中等

        分类：链表

        难度与分类由我所参与的培训课程提供，但需要注意的是，难度与分类仅供参考。且所在课程未提供测试平台，故实现代码主要为自行测试的那种，以下内容均为个人笔记，旨在督促自己认真学习。

题目

        给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回u。为了表示给定链表中的环，使用整数pos来表示链表尾连接到链表中的位置(索引从0开始)。如果pos是-1，则在该链表中没有环。

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

        额外要求，不允许修改给定的链表

思路

        为了解决这个问题，首先需要了解 Floyd 的循环检测算法，又称为龟兔赛跑算法。该算法的核心思想是使用两个指针以不同的速度移动：一个快指针（通常称为 “hare”）和一个慢指针（通常称为 “tortoise” 或 “turtle”）。“hare” 以两倍的速度移动（两个节点一次），而 “tortoise” 以单倍速度移动（一个节点一次）。

        当两个指针都进入环时，快指针最终会追上慢指针。这是因为每次移动时，快指针都比慢指针多走一步。一旦快慢指针在环内相遇，我们就可以确定链表内确实存在一个环。

        接下来，找出环的入口点。当快慢指针第一次相遇，将快指针（或慢指针）重新设置到链表起点，这次两个指针都以相同速度前进，每次移动一个节点。当它们再次相遇的点，就是环的入口。

示例

        假设有以下链表：

    3 -> 2 -> 0 -> -4
         ^          |
         |          v
         <----------

1. 初始化两个指针 turtle（乌龟） 和 hare（兔子），它们都指向链表的头部节点 head（值为3的节点）。

2. 循环开始，hare 以2步的速度移动，turtle 以1步的速度移动。在第一次迭代后，turtle 指向值为2的节点，hare 指向值为-4的节点。

3. 继续迭代，hare 继续2步步进（移动到值为2的节点，因为链表有环），turtle 移动1步（现在指向值为0的节点）。

4. 继续迭代，由于环的存在，hare 和 turtle 最终在值为0的节点相遇。这意味着链表有环。

5. 在确认链表有环之后，将其中一个指针（这里是 turtle）移回到链表的头部，然后以相同的速度（每次移动一步）移动两个指针，当它们相遇时，即为环的起点。

6. 在这个迭代中，turtle 从值为3的节点开始，而 hare 从值为0的节点开始。二者都向前移动一步。在第二步中，turtle 指向值为2的节点，hare 也指向值为2的节点，二者相遇，这就是环的入口节点。

梳理

        当检测到环存在时，根据 Floyd 的循环检测算法，我们可以确定环入口的位置。这是由以下数学逻辑得出的：

        让我们假设：

• 链表头部到环入口的距离有 A 个节点
• 环入口到乌龟和兔子的相遇点有 B 个节点
• 相遇点回到环入口有 C 个节点

        因此，当乌龟和兔子在相遇点相遇时：

• 乌龟走了 A + B 步
• 兔子走了 A + B + k(C + B) 步，其中 k 是兔子在环里跑了完整的圈数

        因为兔子走得快（速度是乌龟的两倍），所以兔子走的步数是乌龟的两倍，得到等式：

• 2(A + B) = A + B + k(C + B)
• 通过简化等式我们得到 A = k(C + B) - B
• 进一步简化得到 A = C + (k-1)(C + B)

        这个等式表示：从头部到环入口的距离 A 等于相遇点到环入口的距离 C 加上 (k-1) 个环的长度 (C + B)。

        等式说明从链表头部到环入口的距离可以通过从相遇点继续走过 C，又或者走过 C + 整数倍的环长度(因为完整走过环的任何倍数，你都会再次回到相同的点)。这正是 Floyd 算法中的关键部分。

        因此，我们可以：

1. 将一个指针重置到链表的起点。
2. 让两个指针（一个从链表起点，另一个从相遇点）以相同的速度移动，每次一步。
3. 两个指针相遇的地方就是环入口。

        所以，当这两个指针再次相遇时，该位置就是链表的环入口节点。在前面的例子中，图形化的解释就是，从头节点出发到达环入口（节点值2）需要走两步，从相遇点（节点值0）继续走回到环入口（节点值2）也正好是两步，因此两个指针会在环入口节点相遇。

代码

#include  // 引入输入输出流库
using namespace std; // 使用标准命名空间

// 链表节点定义
struct ListNode {
    int val;          // 节点值
    ListNode* next;    // 下一个节点指针
    ListNode(int x) : val(x), next(nullptr) {} // 初始化构造函数
};

// 检测链表是否有环，并返回环入口节点的函数
ListNode *getIntersectionNode(ListNode *head) {
    ListNode *turtle = head; // 初始化慢指针为头部
    ListNode *hare = head;   // 初始化快指针为头部

    // 使用快慢指针检测环
    bool isCycle = false; // 记录是否存在环
    while (hare != nullptr && hare->next != nullptr) {
        turtle = turtle->next;           // 慢指针前进一步
        hare = hare->next->next;         // 快指针前进两步
        
        if (turtle == hare) {            // 若快慢指针相遇
            isCycle = true;              // 确认有环
            break;                       // 跳出循环
        }
    }

    if (!isCycle) {
        return nullptr; // 无环返回 nullptr
    }

    // 寻找环的入口
    turtle = head; // 将慢指针重置到头部
    while (turtle != hare) { // 当快慢指针不相遇
        turtle = turtle->next; // 慢指针前进一步
        hare = hare->next;     // 快指针前进一步
    }
    return hare; // 返回环的入口节点
}

// 主函数
int main() {
    // 创建链表并设置成环形
    ListNode *head = new ListNode(3);  // 头部节点值为3
    head->next = new ListNode(2);      // 第二个节点值为2
    head->next->next = new ListNode(0); // 第三个节点值为0
    head->next->next->next = new ListNode(-4); // 第四个节点值为-4
    // 设置环形链表指向位置 pos = 1，即节点值为2的节点
    head->next->next->next->next = head->next;

    // 检测环入口节点
    ListNode *entry = getIntersectionNode(head);

    // 如果存在环入口节点则输出，否则输出 nullptr
    if (entry != nullptr) {
        cout << "节点" << entry->val << endl; // 存在环，输出环入口节点的值
    } else {
        cout << "nullptr" << endl; // 无环的情况，输出 nullptr
    }

    // 已省略删除链表节点。

    return 0; // 程序结束
}

打卡