LeetCode算法题：环形链表II

题目描述如下：

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

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

说明：不允许修改给定的链表。

示例 1：

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

示例 2：

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

示例 3：

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

进阶：
你是否可以不用额外空间解决此题？

这道题目如果可以修改给定链表的话是非常简单的，因为可以改变链表里节点值的类型，然后遍历链表，如果遍历到的节点的值类型是修改后的类型，那么入口节点就是这个节点。（实在写不出来的可以用这种方法，空间消耗击败了百分百的提交）

Python3代码如下：

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

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        temp = head
        i = 1
        
        while temp!=None:
            if isinstance(temp.val,dict)==True:
                return temp
            
            elif isinstance(temp.val,int)==True:
                temp.val = {i:temp.val}
            
            temp = temp.next
            i = i + 1

正规的、符合题意的进阶做法，是官方给出的一种叫Floyd 的算法。

Floyd 算法是分两个阶段来做的，第一个阶段利用快慢指针法找出链表是否有环（这道题的快慢指针法的详解，大家可以参考我的另一篇博客：https://blog.youkuaiyun.com/Viadimir/article/details/102633859）；第二阶段的思路是：给定阶段 1 找到的相遇点，阶段 2 将找到环的入口。首先我们初始化额外的两个指针： ptr1 、ptr2，ptr1指向链表的头， ptr2 指向相遇点。然后，我们每次将它们往前移动一步，直到它们相遇，它们相遇的点就是环的入口，返回这个节点。

关于这两个指针为什么一定会在入口处相遇，官方解释如下：

 Python3代码如下：

class Solution(object):
    def getIntersect(self, head):
        tortoise = head
        hare = head

        # A fast pointer will either loop around a cycle and meet the slow
        # pointer or reach the `null` at the end of a non-cyclic list.
        while hare is not None and hare.next is not None:
            tortoise = tortoise.next
            hare = hare.next.next
            if tortoise == hare:
                return tortoise

        return None

    def detectCycle(self, head):
        if head is None:
            return None

        # If there is a cycle, the fast/slow pointers will intersect at some
        # node. Otherwise, there is no cycle, so we cannot find an e***ance to
        # a cycle.
        intersect = self.getIntersect(head)
        if intersect is None:
            return None

        # To find the e***ance to the cycle, we have two pointers traverse at
        # the same speed -- one from the front of the list, and the other from
        # the point of intersection.
        ptr1 = head
        ptr2 = intersect
        while ptr1 != ptr2:
            ptr1 = ptr1.next
            ptr2 = ptr2.next

        return ptr1