链表带环问题

目录

题目一：判断链表是否带环

1、解题方法

2、证明

1、为什么快指针每次走两步、慢指针每次走一步就可以？

2、快指针每次走3步，走4步，……n步行吗？

 3、代码

题目二：找链表入环第一个结点

 1、解题方法一与证明

2、代码

1、解题方法二

2、代码

---

题目一：判断链表是否带环

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

1、解题方法

一个快指针，一个慢指针，从链表起始位置开始，快的每次走两步，慢的走一步

如果链表带环，则它们一定会在环中相遇，否则，快指针会先走到尾。

2、证明

1、为什么快指针每次走两步、慢指针每次走一步就可以？

快指针每次走两步，慢指针每次走一步，快指针先入环，当慢指针入环是，他们可能就刚好相遇了，最差的情况就是两个指针相差环的长度，此时，两个指针每动一次，他们的距离就缩小一步，在慢指针走完一圈之前，他们一定会相遇。

2、快指针每次走3步，走4步，……n步行吗？

假设快指针每次走3步，慢指针每次走1步，是永远不会相遇的，为什么呢？

假设slow和fast最开始距离为N，则他们之间的距离变化：N，N-2,N-4……（最后能减到0吗）

（1）如果N是偶数，则他们之间的距离是可以减到0的。N，N-2,N-4……4，2，0

（2）如果N是奇数，则他们之间的距离无法减到0。N，N-2,N-4……3，1，-1

减到-1就意味着slow和fast的距离变成了周长减1，相当于进入了新的一轮追击，此时，新的追击能否追上，又要分情况讨论了。

如果slow每次走1步，fast每次走4步：

 3、代码

/**
 * 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) {
        struct ListNode*slow,*fast;
        slow=fast=head;
        while(fast&&fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
            if(slow==fast)
                return true;
        }
        return false;
    }
};

题目二：找链表入环第一个结点

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

 1、解题方法一与证明

解题方法：

让一个指针从链表起始位置开始遍历链表，同时另一个指针从相遇点的位置开始绕环运行，两个指针每次均走一步，最终会在入口点的位置相遇。

设起始点与与入口点距离为L，入口点与相遇点距离为X，环周长为C，

fast走过的路程：L+X+nC（fast走了n圈，slow才进环）

slow走过的路程：L+X

因为快指针速度是慢指针两倍，所以有：

2（L+X）=L+X+nC

化简得：L=nR-X

2、代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *slow,*fast;
    slow=fast=head;

    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;

        if(fast==slow)
        {
            struct ListNode*meet=fast;
            struct ListNode*start=head;

            while(meet!=start)
            {
                meet=meet->next;
                start=start->next;
            }
            return meet;
        }
    }
    return NULL;

}

1、解题方法二

把相遇点跟相遇点的下一个结点断开，再转换成找链表交点问题，之前的博客有讲。

2、代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode*tailA,*tailB;
    int lenA=1,lenB=1;
    tailA=headA;
    tailB=headB;
    while(tailA)
    {
        tailA=tailA->next;
        lenA++;
    }
    while(tailB)
    {
        tailB=tailB->next;
        lenB++;
    }
    if(tailB!=tailA)
    {
        return NULL;
    }
 
 
    int gap=abs(lenA-lenB);
    struct ListNode*longList=headA,*shortList=headB;
    if(lenA<lenB)
    {
        longList=headB;
        shortList=headA;
    }
    while(gap--)
    {
        longList=longList->next;
    }
    while(longList!=shortList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return longList;
 
 
}
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode*slow,*fast;
    fast=slow=head;

    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        
        if(slow==fast)
        {
            struct ListNode*meet=slow;
            struct ListNode*lt1=meet->next;
            struct ListNode*lt2=head;
            meet->next=NULL;
            return getIntersectionNode(lt1,lt2);
        }
    }
    return NULL;
}