给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

示例 1：
输入： head = [3,2,0,-4], pos = 1
输出： true
解释： 链表中有一个环，其尾部连接到第二个节点。

示例 2：
输入： head = [1,2], pos = 0
输出： true
解释： 链表中有一个环，其尾部连接到第一个节点。

示例 3：
输入： head = [1], pos = -1
输出： false
解释： 链表中没有环。

进阶：
你能用 O(1)（即，常量）内存解决此问题吗？

题目分析：
这道题要求我们找出链表是否存在环。我们先考虑当链表无环时是怎样的呢？如果一个链表无环，那么当我们从头开始遍历该链表到最后，每个点都只会被遍历一次，并且结尾一定会存在一个空节点，标记我们的链表遍历结束。那么当链表有环时，当我们遍历该链表时，从链表中的某个点开始，这个环中的点会被反复遍历。如示例1所示，从节点2开始，2,0,4节点被反复遍历。既然有节点重复，我们的直观想法就是建立一个哈希表，该表中存储节点的地址，如果当地址在该哈希表中存在时就表明有重复节点出现，说明环存在。否则算法遍历到链表末尾空节点结束。该算法只是遍历链表所以时间复杂度为O(n)，n为链表的长度，因为我们额外建立了一张哈希表来存储每一个节点的地址，所以空间复杂度也是O(n)。

在面试中一开始如果你说出了一个这样的初始解法，都会给面试官一个还算靠谱的印象。但这道题作为一道简单题，面试官听了你的上述思路后并不会急于让你实现，而是会期望你给出一个空间复杂度为O(1)的解法，也就是本题的进阶要求。

本题我们还是可以继续使用链表题目中常见的快慢指针这一解题思路来进行解答。我们平时在绕着操场跑步时都有过这样的体验，有的人跑的很快，而自己跑的很慢，那么跑的快的那个人就会在某个时刻赶上或者超过我们。那么这里也是同样的，我们的慢指针每次只走一步，快指针每次走两步，如果链表没有环，快指针率先遍历完链表到达链表末尾。如果链表有环，那么在某个点快慢指针一定会相遇（即快慢指针有一样的地址），相遇时我们就可以说链表中存在环了。这里我们只用了快慢指针的额外存储空间，所以我们的空间复杂度就是O(1)。
其实计算机科学家们已经对此类环探测问题设计了相应的理论和算法，我们上述的描述的形式化算法描述叫做Floyd Cycle Detection（佛洛依德环检测算法），有兴趣的同学可以在网络上搜索相应资料深入了解一下。

有了上述的想法，其实代码写出来就很直接了，下面给出5种语言的实现。
c++实现

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

Go语言实现

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func hasCycle(head *ListNode) bool {
    if head == nil || head.Next == nil {
        return false
    }

    var slow *ListNode = head
    var fast *ListNode = head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            return true
        }
    }

    return false
}

Java实现

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }
}

C#实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public bool HasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
            var fast = head;
            var slow = head;
            while (fast != null && fast.next != null)
            {
                fast = fast.next.next;
                slow = slow.next;
                if (fast == slow)
                {
                    return true;
                }
            }
            return false;
    }
}

Python实现

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        if head == None or head.next == None:
            return False
        slow = head
        fast = head
        while fast != None and fast.next != None:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

最后也请大家想一下，如果我们想把环的第一个节点找出来，我们还需要怎么设计我们的算法呢？