算法记录（2）龟兔赛跑

前言
最近在刷牛客的剑指offer，刷的过程中会遇到各种各样的算法，用此系列贴记录下来。
题目描述
给定一个链表，判断链表中是否有环。

---

老生长谈问题，判断链表中是否有环。常用的两种方法：哈希表和快慢指针。
发现力扣官方管快慢指针叫[Floyd 判圈算法]/[龟兔赛跑算法]，遂记录下来。

当一个链表有环，显然放在循环里遍历它就出不来了，也不能说我写个代码，能从循环里出来的是无环链表，出不来的是有环链表。
编不下去了，贴百度百科解释：
Floyd判圈算法(Floyd Cycle Detection Algorithm)，又称龟兔赛跑算法(Tortoise and Hare Algorithm),是一个可以在有限状态机、迭代函数或者链表上判断是否存在环，以及判断环的起点与长度的算法。

可以解决三个问题：
1.是否有环
2.环的大小
3.环的起点

1.是否有环
用两个指针，一个速度为1往下遍历，一个速度为2往下遍历，只要有环，无论如何最终两个指针都会相遇，相遇即可返回true，即有环。

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

2.环的大小
当两个指针相遇时，保持其中一个指针不动，直到另一个指针与它再次相遇，中间走了几步，环就有多大。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int hasCycle(ListNode *head) {
        ListNode *p=head;
        ListNose *q=head;
        while(p!=q){
            p=p->next;
            q=q->next->next;
        }

        int n = 1;
        q=q->next;
        while(p!=q)){
            q=q->next;
            n++;
        }
        return n;
    }
};

3.环的起点
这个的原理有点复杂，我就不列了，在这里写方法。
两个指针分别以速度为1速度为2行进，第一次相遇的时候把其中一个指针放到起点，然后两个指针以相同的速度，再次相遇的地方就是环的起点。