【剑指offer】JZ23-链表中环的入口节点-Python解法

1.题目描述

2.解题思路（Python版）

方法：双指针法

思路：

根据题目描述，需要找到一个链表环的入口节点，这个题目可以拆分成三个小问题：

（1）如何确定一个链表中是否包含环？

（2）如果有环，环中节点的数目如何计算？

（3）如何找到环的入口？

接下来分别解决上述三个问题：

（1）如何确定一个链表中是否包含环：有环链表与无环链表之间最大的区别是在有环链表找不到一个Next域为空的节点（p.next = NULL不存在），可以使用双指针法来判断链表是否包含环，定义两个指针，同时从链表的头节点出发，一个指针一次走一步（慢指针），另一个指针一次走两步（快指针），如果走得快的指针追上了走得慢的指针，那么链表就包含环；如果走得快的指针走到了链表末尾还没有遇到走得慢的指针，那么链表就不包含环；

（2）如果有环，环中节点的数目如何计算：在使用双指针法时判断是否有环时，可以确定两个指针相遇的节点一定是在环中，可以指定一个指针，从相遇节点出发，一边继续向前移动一边计数，等下一次回到相遇节点时，就得到了环中的节点数目；

（3）如何找到环的入口：继续使用双指针来解决这个问题，先定义两个指针同时指向链表的头节点，假设链表的环中共有n个节点，那么快节点现在链表上向前移动n步，然后两个指针以相同的速度向前移动，当第二个指针指向环的入口节点时，第一个指针绕环一周回到入口节点，该相遇节点就是环的入口。

参考代码：

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        MeetNode = self.MeetingNode(pHead)    #相遇节点
        if MeetNode is None:
            return None
        NodesInLoop = 1     #计算环中节点个数
        cur = MeetNode
        while cur.next != MeetNode:
            cur = cur.next
            NodesInLoop = NodesInLoop + 1
        pFast = pHead
        pSlow = pHead
        for i in range(NodesInLoop):  #快指针先走n步
            pFast = pFast.next
        while pFast != pSlow:
            pFast = pFast.next
            pSlow = pSlow.next
        return pSlow

    #定义一个函数，判断原始链表是否有环，如果有的话输出相遇节点
    def MeetingNode(self,pHead):
        if pHead is None:   #判断链表是否为空
            return None
        pFast = pHead       #定义两个指针
        pSlow = pHead
        while pFast is not None and pFast.next is not None:
            pFast = pFast.next.next
            pSlow = pSlow.next
            if pFast == pSlow:
                return pSlow
        return None

复杂度：

时间复杂度O(N)：N为链表长度，最坏情况下遍历链表3次；

空间复杂度O(1)：除辅助指针外未使用其他辅助空间。

补充方法：

仍然使用双指针法解题，但通过如下的推导可以省略之前方法中的第二步（即计算环中节点个数）：

指定一个快指针，一个慢指针，同时从链表的头节点出发，快指针一次走两步，慢指针一次走一步。若链表中有环，那么在慢指针进入链表环之前，快节点已经进入循环，这样两者才可以在环内相遇。

假设两个节点相遇之前，快指针在环内走了圈，慢指针在环内走了圈，而链表进入环之前的距离为，环的入口到相遇点的距离为，相遇点到环入口的距离为。则相遇时快指针一共走了步，慢指针一共走了步，又因为快指针的前进速度是慢指针的两倍，因此，整理一下可得,其中为从链表起点到相遇点的节点个数，是环的大小，说明从链表头经过环入口到达相遇点经过的距离等于整数倍环的大小。

发现这个规律后，可以使用下述步骤完成算法：

1.判断链表中是否有环，并找到相遇的节点；

2.指定两个指针，一个指向相遇节点，另一个节点从链表头开始遍历，两者再次相遇的地方就是环的入口。

参考代码：

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        MeetNode = self.MeetingNode(pHead)    #相遇节点
        if MeetNode is None:
            return None
        pFast = pHead    #快指针指向头节点
        pSlow = MeetNode    #慢指针指向相遇节点
        while pFast != pSlow:     #两个指针依次遍历直到相遇
            pFast = pFast.next
            pSlow = pSlow.next
        return pSlow  

    #定义一个函数，判断原始链表是否有环，如果有的话输出相遇节点
    def MeetingNode(self,pHead):
        if pHead is None:   #判断链表是否为空
            return None
        pFast = pHead       #定义两个指针
        pSlow = pHead
        while pFast is not None and pFast.next is not None:
            pFast = pFast.next.next
            pSlow = pSlow.next
            if pFast == pSlow:
                return pSlow
        return None

复杂度：

时间复杂度O(N)：N为链表长度，最坏情况下遍历链表2次；

空间复杂度O(1)：除辅助指针外未使用其他辅助空间。