142. 环形链表 II

题目描述：

给定一个链表的头节点  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) 空间解决此题？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析：

        仍然是快慢指针，我的想法有些复杂，但也能解决问题。

        计算慢指针p1走过的步数step1，计算快指针走过的步数stpe2，则p2和p1相遇的时候，step2-step1=n*circle，即step2-step1，距离为环的n圈的长度。因为p2和p1相遇，p2肯定是超过了p1若干圈。

        记下dis=step2-step1。定义指针p3=head，然后p1每次移动一步，判断p1是否等于p3。直到p1走了dis步，仍没有遇到p3，说明p3不是入环节点。

        p3移动一步，再次移动p1，每次移动一步，判断p1是否等于p3。直到p1走了dis步，仍没有遇到p3，说明p3不是入环节点。

        重复以上步骤，直至找到入环节点

代码如下：

/**
 * 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) {
        if(head==NULL) return NULL;
        ListNode *p1;
        ListNode *p2;
        p1=p2=head;
        int step1=0;
        int step2=0;
        while(p1!=NULL&&p2!=NULL)
        {
            if(p1->next!=NULL)
            {
                p1=p1->next;
                step1++;
            }
            else 
                return NULL;
            if(p2->next!=NULL)
            {
                p2=p2->next;
                step2++;
            }
            else 
                return NULL;
            if(p2->next!=NULL)
            {
                p2=p2->next;
                step2++;
            }
            else 
                return NULL;
            if(p1==p2) break;
        }
        int ncircle=step2-step1;
        ListNode *p3=head;
        while(true)
        {
            while(ncircle--)
            {
                p1=p1->next;
                if(p1==p3)
                    return p1;
            }
            p3=p3->next;
            ncircle=step2-step1;
        }
        return NULL;
    }
};

其实，忽略了一个关键的要素。

        step2-step1-n*circle中，step2=2*step1，因为p2每次移动两步，p1每次移动一步，p2走的距离永远是p1的两倍。

        因此，上式可以改为，step1=n*circle。 

         通过数学分析可知，n=1，因此step=circle，即p1走过的距离step1，恰好为一圈的长度circle。设环外距离为a，环内p1走过的距离为b，显然有：step1=a+b=circle

        因此p1现在距离入环点的距离为 circle-b=a；而新建一个指针p3，指向head，p3移动到入环点的距离也是a，故同时移动p1和p3，每次移动一步，二者相遇的地方，就是入环点。

关于严谨的数学分析，请看题解：

https://leetcode-cn.com/problems/linked-list-cycle-ii/solution/huan-xing-lian-biao-ii-by-leetcode-solution/

代码如下：

/**
 * 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) {
        // 链表为空，返回空
        if(head==NULL) return NULL;
        // p1和p2分别代表快慢指针 初始化指向头节点
        ListNode *p1;
        ListNode *p2;
        p1=p2=head;
        // p1每次移动一步，p2每次移动两步，
        // 直到p1或者p2到达尽头（不为环，返回NULL）,或者p1和p2相遇
        while(p1!=NULL&&p2!=NULL)
        {
            if(p1->next!=NULL)
                p1=p1->next;
            else 
                return NULL;
            if(p2->next!=NULL)
                p2=p2->next;
            else 
                return NULL;
            if(p2->next!=NULL)
                p2=p2->next;
            else 
                return NULL;
            if(p1==p2) break;
        }
        // p3指向head
        ListNode *p3=head;
        // p3和p1每次移动一个节点，他们一定相遇，并且相遇的节点即为入环节点
        while(true)
        {
            if(p1==p3) return p1;
            p1=p1->next;
            p3=p3->next;
        }
        return NULL;
    }
};