【刷题】LeetCode有环单链表

记录有环单链表的两道题：

• leetcode 141
• leetcode 142

Leetcode 141 Linked List Cycle

第一道题比较简单，说的是给出一个单链表，判断是否有环。
这是双指针的简单运用。我们给出快慢两个指针fast和slow，一个每次向前走两步，一个每次向前走一步。

如果没有环，则快指针率先到达链表末尾。
如果有环，则快慢指针一定在环上相遇。

道理很简单，因为快指针速度是慢指针的两倍，也就是说每一次移动，二者的路程之差增加一步。从而路程之差构成数列：

0, 1, 2, 3, 4, ..., R-1, R, R+1, ..., 2R, ..., 3R, ...

当慢指针也进入了环上，且二者路程之差为kR的时候，二者就落在了同一个结点上，也就是相遇了。其中，R是环上结点个数。

Leetcode 142 Linked List Cycle II

第二道题则是不仅想知道是否有环，还想知道环的入口在哪个结点。
我们在之前的基础上继续推导。

实际上，无论相遇多少次，快慢指针都是想遇在环上的同一个结点上。

我们假设链表头部结点是A，环入口结点是B，第一次相遇结点是C。那么快慢指针相遇之后继续移动，当二者路程之差增加R的时候，二者再次相遇。此时慢指针移动了R步，快指针移动了2R步，显然二者都回到了结点C的位置。

我们使用 (S_{AB}) 和 (S_{BC}) 分别表示A到B的距离以及B到C的距离。我们注意到：

(S_{AB} + S_{BC} == nR)

我们用 (S_{slow}) 和 (S_{fast}) 分别表示快慢指针第一次相遇的时候，二者走过的路程，则：
(S_{slow} = S_{AB} + S_{BC})
(S_{fast} = S_{AB} + S_{BC} + kR)
注意到二者速度关系，我们有：
(2S_{slow} = S_{fast})
从而可以得出：
(S_{AB} + S_{BC} = kR)
也就是说，快慢指针相遇的结点处，到单链表头部的距离，恰好是环长的整数倍。

有了这个结论之后，我们就可以进行构造，想办法让两个指针在结点B相遇了。方法是：
当快慢指针在C相遇之后，慢指针位置不动，快指针移到链表头结点A处，两个指针都以每次向前走一步的速度前进。

二者必然在环入口结点B处相遇。

快指针从A移动到B，走了 (S_{AB}) 距离，而慢节点此时走过的路程为 (S_{AB} + S_{BC} + S_{AB} = kR + S_{AB})，二者路程恰好相差环长整数倍，也就是在此处相遇。

参考代码

Leetcode 141

// @lc code=start
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    // Given head, the head of a linked list, determine if the linked list has a cycle in it.
public:
    bool hasCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) return true;
        } // case [1]
-1, [1,2]
-1
        return false;
    } // AC
};
// @lc code=end

Leetcode 142

// @lc code=start
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    // Given a linked list, return the node where the cycle begins.
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                break;
            }
        }
        if (fast == nullptr || fast->next == nullptr) return nullptr;
        fast = head;
        while (slow != fast) {
            slow = slow->next;
            fast = fast->next;
        }
        return fast;
    }
};
// @lc code=end