8.找出链表环的入口结点

题目描述

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {

    }
};

链表中有环的解释：参考：http://blog.sina.com.cn/s/blog_a1ce3d4b0102wks6.html

上图中的第二个示例图P2改为P1。

环中结点的数目

1）判断一个链表里是否有环时用到了一快一慢两个指针，如果两个指针相遇，表明链表中存在环。两个指针相遇的结点一定在环中，2）从这个结点出发，一边继续向前移动一位一遍计数，当再次回到这个结点时，就可以得到环中的节点数。

解法1：

 class Solution {
    //找到一快一满指针相遇处的节点，相遇的节点一定是在环中
    public:
     static ListNode* meetingNode(ListNode* head) 
      {
        if(head==NULL)
            return NULL;
        ListNode* slow = head->next;
        if(slow==NULL)
            return NULL;
         
        ListNode* fast = slow->next;
        while (slow != NULL && fast != NULL) {
            if(slow==fast){
                return fast;
            }
            slow=slow->next;
            fast=fast->next;
             
            if(fast!=slow){
                fast=fast->next;
            }
        }
        return NULL;
    }
    public:
     ListNode* EntryNodeOfLoop(ListNode* pHead) 
      {
        ListNode* meetingNode1=meetingNode(pHead);
        if(meetingNode1==NULL)
            return NULL;
//      得到环中的节点个数
        int nodesInLoop=1;
        ListNode* p1=meetingNode1;
        while(p1->next!=meetingNode1){
            p1=p1->next;
            ++nodesInLoop;
        }
//      移动p1
        p1=pHead;
        for(int i=0;i<nodesInLoop;i++){
            p1=p1->next;
        }
//      移动p1，p2
        ListNode* p2=pHead;
        while(p1!=p2){
            p1=p1->next;
            p2=p2->next;
        }
        return p1;
    }
};

解法2： 出错！

class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead==nullptr||pHead->next==nullptr)
            return nullptr;
        ListNode* pSlow=pHead;
        ListNode* pFast=pHead;
        while(pFast!=nullptr&&pFast->next!=nullptr){
            pSlow=pSlow->next;//慢结点走1步
            pFast=pFast->next->next;//快结点走2步
            if(pFast==pSlow)
                return pFast;
        }
        return nullptr;

    }
};
// 故上述的这种情况只满足：环中有结点个数为2的情况

测试结果：

您提交的程序没有通过所有的测试用例
case通过率为50.00%

原因是事前不知道环结点有几个，就pFast走到了第二个指针。

解法:3：其它的思路
//先说个定理：两个指针一个fast、一个slow同时从一个链表的头部出发
//fast一次走2步，slow一次走一步，如果该链表有环，两个指针必然在环内相遇
//此时只需要把其中的一个指针重新指向链表头部，另一个不变（还在环内），
//这次两个指针一次走一步，相遇的地方就是入口节点。
//https://blog.youkuaiyun.com/snow_7/article/details/52181049
https://blog.youkuaiyun.com/WitsMakeMen/article/details/37597291

 class Solution {

    public:
     ListNode* EntryNodeOfLoop(ListNode* pHead){

        if(pHead==nullptr|| pHead->next==nullptr|| pHead->next->next==nullptr)
            return nullptr;
 
        ListNode* fast=pHead->next->next;
 
        ListNode* slow=pHead->next;
        //先判断有没有环
        while(fast!=slow){
            if(fast->next!=nullptr&& fast->next->next!=nullptr)
               {
                fast=fast->next->next;
 
                slow=slow->next;
 
                }
            else
               {
                //没有环,返回
                return nullptr;
            }
        }
        //跳出上述循环，则有环，此时fast=slow.
        fast=pHead;//重新定义fast结点的位置为头结点
        while(fast!=slow)
        {
            fast=fast->next;
            slow=slow->next;
        }
        return slow;
    }
};

通过！

但是没有像之前说的要找出结点的个数！

类似解法：

//左神讲的
//先说个定理：两个指针一个fast、一个slow同时从一个链表的头部出发
//fast一次走2步，slow一次走一步，如果该链表有环，两个指针必然在环内相遇
//此时只需要把其中的一个指针重新指向链表头部，另一个不变（还在环内），
//这次两个指针一次走一步，相遇的地方就是入口节点。
//这个定理可以自己去网上看看证明。https://blog.youkuaiyun.com/snow_7/article/details/52181049
//https://www.cnblogs.com/snake-hand/p/3148328.html
class Solution {
    public: 
    ListNode* EntryNodeOfLoop(ListNode* pHead){
        ListNode* fast = pHead;
        ListNode* slow = pHead;
        while(fast != NULL  && fast->next !=NULL){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)
                break;
        }
        if(fast == NULL || fast->next == NULL)
            return NULL;
        fast=pHead;
        while(fast!=slow){
            fast=fast->next;
            slow=slow->next;
        }
        return fast;
    }
};

 

参考：

【1】https://www.nowcoder.com/questionTerminal/253d2c59ec3e4bc68da16833f79a38e4

【2】思路2的定理 https://blog.youkuaiyun.com/WitsMakeMen/article/details/37597291 待续