【Leetcode C++】2_5. [code] 环形链表Ⅰ、Ⅱ

5. [code] 环形链表Ⅰ、Ⅱ

5.1. 题目

• Leetcode 141

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

示例1：

输入：head = [3,2,0,-4], pos = 1

输出：true

解释：链表中有一个环，其尾部连接到第二个节点。

示例2：

输入：head = [1,2], pos = 0

输出：true

解释：链表中有一个环，其尾部连接到第一个节点。

示例3：
输入：head = [1], pos = -1

输出：false

解释：链表中没有环。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

• Leetcode 142

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

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

在141的基础上，如果有环，还需要输出环尾部连接到第几个节点。

示例1：

输入：head = [3,2,0,-4], pos = 1

输出：tail connects to node index 1

解释：链表中有一个环，其尾部连接到第二个节点。

5.2. 思路

141

• 方法1：哈希表

思路:

我们可以通过检查一个结点此前是否被访问过来判断链表是否为环形链表。常用的方法是使用哈希表。

算法:

我们遍历所有结点并在哈希表中存储每个结点的引用（或内存地址）。如果当前结点为空结点 null（即已检测到链表尾部的下一个结点），那么我们已经遍历完整个链表，并且该链表不是环形链表。如果当前结点的引用已经存在于哈希表中，那么返回 true（即该链表为环形链表）。

• 方法2：快慢指针

思路

想象一下，两名运动员以不同的速度在环形赛道上跑步会发生什么？

算法

通过使用具有 不同速度的快、慢两个指针遍历链表，空间复杂度可以被降低至 O(1)O(1)。慢指针每次移动一步，而快指针每次移动两步。

如果列表中 不存在环，最终快指针将会最先到达尾部，此时我们可以返回 false。

现在考虑一个 环形链表，把慢指针和快指针想象成两个在环形赛道上跑步的运动员（分别称之为慢跑者与快跑者）。而快跑者 最终一定会追上慢跑者。这是为什么呢？考虑下面这种情况（记作情况 A）。
假如快跑者只落后慢跑者一步，在下一次迭代中，它们就会分别跑了一步或两步并相遇。

其他情况又会怎样呢？例如，我们没有考虑快跑者在慢跑者之后两步或三步的情况。但其实不难想到，因为在下一次或者下下次迭代后，又会变成上面提到的情况 A。

142

与141相比，需要输出环入口的位置。这里利用快指针的速度是慢指针速度的2倍，证明出从链表头到环入口的距离与相遇点到环入口的距离相当，i.e. H=D.

证明：fast指针和slow指针同时从链表头出发，fast指针的速度是slow指针的两倍(eg.slow速度是v,fast速度是2v)。假设链表头到环入口的距离是H，则，当slow指针到达环入口（即slow走了H距离）时，fast指针到达图示蓝色箭头位置，（即fast走过的距离为2H，距离入口位置H)。假设再经过一段时间t,slow与fast相遇于黄色三角标记处，根据图示，

$$t=\frac{H+S}{v}=\frac{S+(H+S+D)}{2V}$$

因此$H=D$

5.3. 代码

141

• 方法1：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        std::set<ListNode *> node_set;
        while(head){
            if (node_set.find(head) != node_set.end()){
                return true;
            }
            node_set.insert(head);
            head = head->next;
        }
        return false;
    }
};

• 方法2：

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if (head==NULL || head->next==NULL){
            return false;
        }
        ListNode* fast = head->next;
        ListNode* slow = head;
        while(slow != fast){
            if(fast==NULL || fast->next==NULL){
                return false;
            }
            slow->next;
            fast->next->next;
        }
        return true;
    }
};

142

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow = head;
        ListNode *meet = NULL;
        while(fast){
            slow = slow->next;
            fast = fast->next;
            if(!fast){
                return NULL;
            }
            fast = fast->next;
            if(fast==slow){
                meet = fast;
                break;
            }
        }
        if (meet == NULL){
            return NULL;
        }
        while(head && meet){
            if(head==meet){
                return head;
            }
            head = head->next;
            meet = meet->next;
        }
        return NULL;
    }
};