LeetCode Linked List Cycle & Linked List Cycle II题解

• Linked List Cycle

 

        Given a linked list, determine if it has a cycle in it.Follow up:Can you solve it without using extra space?

        题目的意思就是在利用O（1）的空间判断一个链表是否存在环。我一开始的想法就是，每访问 一个节点，就遍历这个节点前面的所有节点，然后判断是否相同，如果相同就说明有环。如果所有的节点都访问完了还是没有发现有节点相同，则说明该链表没有环。但是这个想法很快被毙掉，因为这个算法的复杂度将会达到O(N^2)，实在太慢！后来又想到了利用两个指针，一快一慢，如果有环，则这两个指针一定会相遇。这个方法不需要额外的空间，同时复杂度是O（N）的。非常符合这道题目的要求。具体来说，就是设立两个指针，一个fast，一个slow。fast在每一个step中移动两步，slow每次移动一步。如果两者相遇，必然是存在环，同时fast将slow套圈了才会出现这种情况。这道题目也就迎刃而解了，具体的实现代码如下。

class Solution {public:    bool hasCycle(ListNode *head) {        if(!head || !head->next)            return false;                    ListNode *fast,*slow;        fast = slow = head;        bool flag = false;        while(fast)        {            fast = fast->next;            if(flag)            {                slow = slow->next;                flag = false;            }            else            {                flag = true;            }            if(fast == slow)                return true;        }        return false;    }};

• Linked List Cycle II

        Given a linked list, return the node where the cycle begins. If there is no cycle, returnnull. Follow up:Can you solve it without using extra space?

        Linked List Cycle II 不仅要求判断是否存在环，同时还需要在存在环的情况下找出环的起始节点。这就比I要难一些。最开始我想到的方法还是跟上题类似，一个fast ，每次移动两步，一个slow，每次移动一步。两个指针不仅要向前移动，同时还需要记录各自走的步数（fastCount和slowCount）。当相遇的时候，fastCount减去slowCount就是换的长度（假设这个长度的len）。这个时候让fast和slow重新指向head节点。然后先让fast指针向前移动len步。之后fast和slow再同时移动，两个每次均移动一步。当两者相遇的时候就是环的其实节点。具体代码如下：

class Solution {public:    ListNode *detectCycle(ListNode *head) {        if(!head || !head->next)            return NULL;        ListNode *fast,*slow;        int fastCount = 1,slowCount = 1;        bool hasCycle = false, flag = false;        fast = slow = head;        while(fast)        {            fast = fast->next;            ++fastCount;            if(flag)            {                slow = slow->next;                ++slowCount;                flag = false;            }            else            {                flag = true;            }            if(fast == slow)            {                hasCycle = true;                break;            }                    }                if(!hasCycle)            return NULL;        int cycleLen = fastCount - slowCount;                fast = slow = head;        for(int i = 0; i < cycleLen; ++i)            fast = fast->next;        while(true)        {            if(fast == slow)                return slow;            fast = fast->next;            slow = slow->next;        }    }};

        但是在参考了他人的算法之后，发现这个算法可以更加精简。先来看下面这个图。

       

          p1为环开始的节点，p2为fast指针和slow指针相遇的节点。A 、B、 C分别为三段的距离。当相遇的时候slow指针经过的路程为（A + B）而fast指针经过的路程为(A + B + C + B)。同时fast经过的路程又是slow的两倍，所以又（A + B + C + B）= 2（A + B）所以最后得到A = C！那么当两者相遇的时候，只需要将slow指针放回到起始节点，而fast指针继续在原有位置上向前走。两个指针一相同的速度访问节点。当两者再次相遇的时候，相遇的节点就是环路起始节点p1。实现代码如下：

class Solution {public:    ListNode *detectCycle(ListNode *head) {        if(!head || !head->next)            return NULL;        ListNode *fast,*slow;        fast = slow = head;        while(fast)        {            fast = fast->next;            if(!fast) return NULL;            fast = fast->next;            slow = slow->next;                        if(fast == slow)//find the cycle            {                slow = head;                while(slow != fast)                {                    fast = fast->next;                    slow = slow->next;                }                return fast;            }        }    }};