141. 环形链表 & 142. 环形链表 II

142. 环形链表 II ●●

描述

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例

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

题解

1. 哈希表

利用 unordered_set<ListNode*> hash; 记录已经遍历的节点指针。

• 时间复杂度：O(N)，其中 N 是链表中的节点数。最坏情况下我们需要遍历每个节点一次。
• 空间复杂度：O(N)，其中 N 是链表中的节点数。主要为哈希表的开销，最坏情况下我们需要将每个节点插入到哈希表中一次。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> hash;
        ListNode* curr = head;
        while(curr != NULL){
            if(hash.count(curr)) return curr;
            hash.insert(curr);
            curr = curr->next;
        }
        return NULL;
    }
};

2. 双指针

在同一起点上，快指针 fast 一次走两步，慢指针 slow 一次走一步，

• 如果没有环，则快慢指针在快指针变为空指针之前都不会相遇；
• 如果有环，则快指针会在环中与慢指针相遇；
  相遇后，将快指针赋值头结点，此时两个指针每次都只走一步，两个指针最终将会在入口处再次相遇。

• 时间复杂度：$O(N)$，其中 N 为链表中节点的数目。在最初判断快慢指针是否相遇时，slow 指针走过的距离不会超过链表的总长度；随后寻找入环点时，走过的距离也不会超过链表的总长度。因此，总的执行时间为O(N)+O(N)=O(N)。

• 空间复杂度：$O(1)$。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;		// 同一起点
        ListNode* fast = head;
        while(fast != NULL && fast->next != NULL){	// 注意是判断 fast 和 fast->next
            slow = slow->next;		// 先移动，再判断
            fast = fast->next->next;
            if(slow == fast){		// 有环
                fast = head;		// 进行入口判断
                while(slow != fast){
                    slow = slow->next;
                    fast = fast->next;
                }
                return slow;
            }
        }
        return NULL;
    }
};

141. 环形链表 ●

描述

给定一个链表的头节点 head ，如果链表中存在环 ，则返回 true 。 否则，返回 false 。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

示例

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

题解

1. 哈希表

利用 unordered_set<ListNode*> hash; 记录已经遍历的节点指针。

• 时间复杂度：O(N)，其中 N 是链表中的节点数。最坏情况下我们需要遍历每个节点一次。
• 空间复杂度：O(N)，其中 N 是链表中的节点数。主要为哈希表的开销，最坏情况下我们需要将每个节点插入到哈希表中一次。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> hash;
        ListNode* curr = head;
        while(curr != NULL){
            if(hash.count(curr)) return true;
            hash.insert(curr);
            curr = curr->next;
        }
        return false;
    }
};

2. 双指针

在同一起点上，快指针 fast 一次走两步，慢指针 slow 一次走一步，

• 如果没有环，则快慢指针在快指针变为空指针之前都不会相遇；
• 如果有环，则快指针会在环中与慢指针相遇。
  

时间复杂度：O(N)，其中 N 是链表中的节点数。

• 当链表中不存在环时，快指针将先于慢指针到达链表尾部，链表中每个节点至多被访问两次。
• 当链表中存在环时，每一轮移动后，快慢指针的距离将减小一。而初始距离为环的长度，因此至多移动 N 轮。

空间复杂度：O(1)。我们只使用了两个指针的额外空间。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;		// 同一起点
        ListNode* fast = head;
        while(fast != NULL && fast->next != NULL){	// 注意是判断 fast 和 fast->next
            slow = slow->next;		// 先移动，再判断
            fast = fast->next->next;
            if(slow == fast){		// 有环
                return true;
            }
        }
        return false;
    }
};