链表带环检测以及环入口

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/

class Solution {
public:
ListNode* detectCycle(ListNode* head)
{
    ListNode *slow=head, *fast=head;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(slow == fast)
        {
            ListNode *slow2=head;
            while(slow2 != slow)
            {
                slow2=slow2->next;
                slow=slow->next;
            }
            return slow;
        }
    }
    return nullptr;
}
};       

class Solution {
public:
    ListNode* MeetingNode(ListNode* pHead)
    {
        if(pHead==nullptr)
            return nullptr;
        
        ListNode* pSlow=pHead->next;
        if(pSlow==nullptr)
            return nullptr;
        
        ListNode* pFast=pSlow->next;
        while(pFast!=nullptr && pSlow!=nullptr)
        {
            if(pFast==pSlow)
                return pFast;
            
            pSlow=pSlow->next;
            
            pFast=pFast->next;
            if(pFast!=nullptr)
                pFast=pFast->next;
        }
        return nullptr;
    }
    
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        ListNode* meetingNode=MeetingNode(pHead);
        if(meetingNode==nullptr)
            return nullptr;
        
        int nodesInloop=1;
        ListNode* pNode1=meetingNode;
        while(pNode1->next!=meetingNode)
        {
            pNode1=pNode1->next;
            ++nodesInloop;
        }
        
        pNode1=pHead;
        for(int i=0;i<nodesInloop;++i)
            pNode1=pNode1->next;
        
        ListNode* pNode2=pHead;
        while(pNode1!=pNode2)
        {
            pNode1=pNode1->next;
            pNode2=pNode2->next;
        }
        return pNode1;
    }
};