刷题心得6-环形链表-快慢指针

题目链接：141. 环形链表 - 力扣（LeetCode）

题面：给你一个链表的头节点 head ，判断链表中是否有环。

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

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目范围是 [0, 104]
• -105 <= Node.val <= 105
• pos 为 -1 或者链表中的一个 有效索引 。

做法：

一开始使用的hash进行求解的（set，非常简单，就不写了）。

题解方法：使用快慢指针，慢指针每次走一步，快指针每次走两步，在环中，快指针和慢指针一定会相遇的，并且一定会在（慢指针到环上的）第一圈就相遇。

为什么会相遇并且在第一圈就相遇：

1. 为何慢指针第一圈走不完一定会和快指针相遇? 可以认为快指针和慢指针是相对运动的，假设慢指针的速度是 1节点/秒，快指针的速度是 2节点/秒，当以慢指针为参考系的话（即慢指针静止），快指针的移动速度就是 1节点/秒，所以肯定会相遇。
2. 为什么在第一圈就会相遇呢？ 设环的长度为 L，当慢指针刚进入环时，慢指针需要走 L 步(即 L 秒)才能走完一圈，此时快指针距离慢指针的最大距离为 L-1，我们再次以慢指针为参考系，如上所说，快指针在按照1节点/秒的速度在追赶慢指针，所以肯定能在 L 秒内追赶到慢指针。 ---------来自 力扣 Rick 的评论，非常容易理解

使用快慢指针的代码：

/**
 * 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) {
        //可以使用快慢指针
        //一个一次走一步，一个一次走两步，一定会相遇
        ListNode *fast = head,*slow = head;
        if(!fast) return false;
        while(1){
            fast = fast->next;
            if(!fast) break;
            fast = fast->next;
            if(!fast) break;
            slow = slow->next;
            if(slow==fast)
                return true;
        }

        return false;
    }
};

环形链表2：进阶版这次是求取入环的位置（之前单纯判断是否有环）

题目链接：142. 环形链表 II - 力扣（LeetCode）

题面：

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

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

不允许修改 链表。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

**进阶：**你是否可以使用 O(1) 空间解决此题？

题解：依然使用快慢指针。

快慢指针到达位置时：

算head到A位置为z

那么z * 2 = z + x + k(x+y) -> z = x + k(x+y)

那么A再走y步，B再走y*2步。 那么就会在y的位置相遇。

那么确定了AB相遇的位置，我们只需要知道y在哪即可。

此时引入一个ptr，并让ptr和slow都保持1个单位的速度，那么就会在A位置相遇，A位置就是入环的位置。

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head,*slow = head;
        while(fast){
            fast=fast->next;
            if(!fast) break;
            fast=fast->next;
            if(!fast) break;
            slow = slow->next;
            if(slow == fast )
                break;
        }
        if(!fast){
            return NULL;
        }else{
            while(slow!=head){
                slow = slow->next;
                head = head->next;
            }
            return slow;
        }

    }
};