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) 空间解决此题？

思路

思路1：模仿数组存储访问过的节点，每次与之相比较。

思路2：快慢指针，判断有无环

解法1

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    //头指针
    struct ListNode * L = (struct ListNode *)malloc(sizeof(struct ListNode));
    L->next = head;
    struct ListNode *p=head,*tmp,*q = L;
   
    //p向前  每次与之前的比较  相等则有环
    while(p)
    {
        tmp = L;
        while(tmp!=q)  //结束条件  
        {
            if(p!=tmp)
            {
                tmp = tmp->next;
            }
            else
            {
                return p;
            }
        }
        q = p;  //p的前驱
        p = p ->next;
        if(p==q)  //特殊情况    存在一个节点的环
        {
            return p;
        }
    }
    return NULL;
}

• 时间复杂度 O(n^2)
• 空间复杂度 O(1)

解法2

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast=head,*slow=head,*tmp=head;
    int fast_k = 0,slow_k=0,i=0;
    while(fast)
    {
        fast=fast->next;
        if(fast!=NULL)
        {
            fast = fast->next;
            fast_k+=2;
        }
        else
        {
            return NULL;
        }
        slow = slow->next;
        slow_k++;
    
        if(slow==fast)
        {
            while(1)
            { 
                if(tmp==slow)    //注意先比较再移动。  顺序错误示，例二不能通过
                {
                    return slow;
                }
                tmp= tmp->next;
                slow=slow->next;    
            }  
        }
    }
    return NULL;
}

步骤1：验证是否有环，即快慢指针是否相遇。      

        1. 使用快慢指针方法确定链表中是否存在环。快指针每次移动两步，慢指针每次移动一步，如果它们最终相遇，则链表中存在环。

步骤2：寻找链表中环的起点

        1. 一旦快慢指针相遇，将慢指针重新指向链表的起点，同时保持快指针在相遇点。

        2. 接下来，快慢指针以相同的速度（每次移动一步）移动，当它们再次相遇时，相遇点即为环的起点。

原理：

        假设链表中起始节点到环入口节点的距离为a，环的起始节点到相遇节点的距离为b，环的长度为c。根据快慢指针算法的原理，当慢指针进入环时，快指针每次比慢指针多走一步，因此每移动一次，快指针与慢指针之间的距离就会减小1。慢指针在环内走一圈肯定会与快指针相遇。慢指针从起始节点到相遇节点的距离是a+b，而快指针从起始节点到相遇节点的距离是a+b+m*c（m是一个正整数，表示快指针在相遇时在环内走的圈数）。因此，a+b=m*c。这意味着从起始节点到相遇节点的距离是环的长度的整数倍。根据这个性质，可以使用快慢指针来判断链表中是否存在环。

        上述可知，当快慢指针相遇时，慢指针走过的距离为环的长度的整数倍（a+b=m*c）。可知a=(m-1)*c+c-b，其中c-b为环的起始节点到相遇节点的距离，对于慢指针而言，慢指针从链表头开始走(m-1)*c+c-b到起点，对于快指针而言，快指针从距离环的起始位置为b开始，快指针再走(m-1)*c+c-b到环的起点。即俩个指针将会在环的起点相遇。