LeetCode之“链表”：Linked List Cycle && Linked List Cycle II

1.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?

　　刚看到这道题，很容易写出下边的程序：

bool hasCycle(ListNode *head) {
    ListNode *a = head, *b = head;
    while(a)
    {
        b = a->next;
        while(b)
        {
            if(a == b)
                return true;
            b = b->next;
        }
        a = a->next;
    }
    
    return false;
}

　　这个程序最大的问题在于“死循环”，例如在下边这种情况就会进入死循环：

　　

　　要解决这个问题，我们可以定义两个指针slow、fast，slow每次前进一步，fast每次前进两步。如果链表存在环，则在循环一定次数后，slow与fast一定会重合（找个例子推导下就明白了）。具体从程序如下：

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

2.Linked List Cycle II

　　题目链接

　　题目要求：

　　Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

　　Follow up:
　　Can you solve it without using extra space?

　　这道题难度还是挺大的。具体解法参考自一博文：

　　首先看图：

　　 

　　从链表起始处到环入口长度为：a，从环入口到Faster和Slower相遇点长度为：x，整个环长为：c。

 　　假设从开始到相遇，Slower走过的路程长为s，由于Faster的步速是Slower的2倍，那么Faster在这段时间走的路程长为2s。

 　　而对于Faster来说，他走的路程还等于之前绕整个环跑的n圈的路程nc，加上最后这一次遇见Slower的路程s。

 　　所以我们有：

                   2s = nc + s 

 　　对于Slower来说，他走的路程长度s还等于他从链表起始处到相遇点的距离，所以有：

                    s = a + x 

 　　通过以上两个式子代入化简有：

                    a + x = nc

                    a = nc - x

                    a = (n-1)c + c-x

                    a = kc + (c-x)

　　那么可以看出，c-x，就是从相遇点继续走回到环入口的距离。上面整个式子可以看出，如果此时有个pointer1从起始点出发并且同时还有个pointer2从相遇点出发继续往前走（都只迈一步），那么绕过k圈以后， pointer2会和pointer1在环入口相遇。这样，换入口就找到了。

　　具体程序如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (true){
            if(!fast || !fast->next)
                return nullptr;
            
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
                break;
        }
        
        slow = head;
        while (slow != fast){
            slow = slow->next;
            fast = fast->next;
        }
        return slow;
    }
};