精选50题之 142. 环形链表 II

原题目链接

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

示例 1：

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

示例 2：

输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

进阶：
你是否可以不用额外空间解决此题？

题目分析

昨天的题目，精选50题之 141. 环形链表
对于环形链表问题，大体上有两种思路

• hash表法：用 Set 保存已经访问过的节点，再遍历并返回第一个出现重复的节点；
• 双指针/快慢指针：从相遇时的状态可以计算/分析出目标结果。

解题分析

既然想到了两种思路，那么就分别 分析并实现?

一、hash表法
其实就是“用 Set 保存已经访问过的节点，再遍历并返回第一个出现重复的节点”

二、双指针/快慢指针法
（参照上一题设计的思路）fast指针每次移动两个，slow指针每次移动一个，同时出发。当first指针追上slow指针时，说明first指针比slow指针多走了一个完整的环形，但这还不是重点。（以下假设环存在）
关键在于，此时相遇的位置。
此时：

• slow经过：非环路径outside，环上部分路径inside_1
• fast经过：非环路径outside，一个环上完整路径（inside_1 和inside_2），环上部分路径inside_1

由于fast指针走过的长度是slow的两倍——消元得到 outside = inside_2。
这就意味着：同时从链表头部和相遇位置出发，单位长度移动，再次相遇的位置就是环形开始的位置（链表尾连接到链表中的位置） 进而得到了目标解。

⚠️似乎公式推到不严谨，思路是正确的

代码实现

一、hash表实现

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        set<ListNode*> hash;
        while(head) 
        {
            // 注意此段语法！
            if (hash.find(head -> next) != hash.end()) 
                return head -> next;
            else 
            {
                hash.insert(head); 
                head = head->next;
            }
        }
        return NULL;
    }
};

复杂度分析：

• 时间复杂度：O(N)
• 空间复杂度：O(N)

二、双指针实现 （又称Floyd 算法）

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == nullptr || head -> next == nullptr) 
            return nullptr;
        ListNode *fast = head, *slow=head, *p = nullptr;
        // 因为初始位置相同，故先移动，后判断
        while(fast != nullptr && fast -> next != nullptr)
        {
            fast = fast -> next ->next;
            slow = slow -> next;
            if(fast == slow) 
            {
                p = slow;
                break;
            };
        }
        if(p == nullptr)
            return nullptr; // 无环形
        ListNode *q = head;
        while(p != q)       //  直至相遇
        {
            p = p -> next;
            q = q -> next;
        }
        return p;
    }
};

复杂度分析：

• 时间复杂度：O(N)
• 空间复杂度：O(1)

写在最后

Bon Voyage!