判断单链表是否有环,并找出环的入口【python】

转载:https://blog.csdn.net/yangnianjinxin/article/details/79025768

2018年01月10日 16:52:24 yangnianjinxin 阅读数:3498

 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yangnianjinxin/article/details/79025768



参考链接:

判断单向列表是否包括环,若包含,环入口的节点计算 python实现 - 鲸落丶 - 博客园 https://www.cnblogs.com/kunpengv5/p/7784791.html

判断链表是否有环以及环的入口点(转载) - 天马行空 - ITeye博客 http://superwind.iteye.com/blog/706887

问题:

1、如何判断一个链表是不是这类链表?

2、如果链表为存在环,如果找到环的入口点?

一、判断链表是否存在环,办法为:

设置两个指针(fast, slow),初始值都指向头,slow每次前进一步,fast每次前进二步,如果链表存在环,则fast必定先进入环,而slow后进入环,两个指针必定相遇。(当然,fast先行头到尾部为NULL,则为无环链表)

二、找到环的入口点,方法:

当fast若与slow相遇时,slow肯定没有走遍历完链表,而fast已经在环内循环了n圈(1<=n)。假设slow走了s步,则 fast走了2s步(fast步数还等于s 加上在环上多转的n圈),设环长为r,则:

2s = s + nr s= nr

设整个链表长L,入口环与相遇点距离为x,起点到环入口点的距离为a。

 a + x = nr

 a + x = (n – 1)r +r = (n-1)r + L - a 

a = (n-1)r + (L – a – x)

(L – a – x)为相遇点到环入口点的距离,由此可知,从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点,于是我们从链表头、与相遇点分别设一个指针,每次各走一步,两个指针必定相遇,且相遇第一点为环入口点。

易于理解的解释: 

一种O(n)的办法就是(搞两个指针,一个每次递增一步,一个每次递增两步,如果有环的话两者必然重合,反之亦然): 

关于这个解法最形象的比喻就是在操场当中跑步,速度快的会把速度慢的扣圈 

可以证明,p2追赶上p1的时候,p1一定还没有走完一遍环路,p2也不会跨越p1多圈才追上 

我们可以从p2和p1的位置差距来证明,p2一定会赶上p1

但是不会跳过p1的 因为p2每次走2步,而p1走一步,所以他们之间的差距是一步一步的缩小,4,3,2,1,0 到0的时候就重合了 

根据这个方式,可以证明,p2每次走三步以上,并不总能加快检测的速度,反而有可能判别不出有环 

既然能够判断出是否是有环路,那改如何找到这个环路的入口呢? 

解法如下:

当p2按照每次2步,p1每次一步的方式走,发现p2和p1重合,确定了单向链表有环路了

 接下来,让p2回到链表的头部,重新走,每次步长不是走2了,而是走1,那么当p1和p2再次相遇的时候,就是环路的入口了。 

这点可以证明的:

 在p2和p1第一次相遇的时候,假定p1走了n步骤,环路的入口是在p步的时候经过的,那么有 p1走的路径: p+c = n;  

 c为p1和p2相交点,距离环路入口的距离 p2走的路径: p+c+k*L = 2*n;  

 L为环路的周长,k是整数 显然,如果从p+c点开始,p1再走n步骤的话,还可以回到p+c这个点 

同时p2从头开始走的话,经过n步,也会达到p+c这点

 显然在这个步骤当中p1和p2只有前p步骤走的路径不同,所以当p1和p2再次重合的时候,必然是在链表的环路入口点上。

python 代码:

 
  1. class Node(): #定义一个Node类,构造两个属性,一个是item节点值,一个是节点的下一个指向

  2. def __init__(self,item=None):

  3. self.item = item

  4. self.next = None

  5.  
  6. def findbeginofloop(head):#判断是否为环结构并且查找环结构的入口节点

  7. slowPtr = head #将头节点赋予slowPtr

  8. fastPtr = head #将头节点赋予fastPtr

  9. loopExist =False #默认环不存在,为False

  10. if head == None: #如果头节点就是空的,那肯定就不存在环结构

  11. return False

  12. while fastPtr.next != None and fastPtr.next.next != None: #fastPtr的下一个节点和下下个节点都不为空

  13. slowPtr = slowPtr.next #slowPtr每次移动一个节点

  14. fastPtr = fastPtr.next.next #fastPtr每次移动两个节点

  15. if slowPtr == fastPtr : #当fastPtr和slowPtr的节点相同时,也就是两个指针相遇了

  16. loopExist = True

  17. print("存在环结构")

  18. break

  19.  
  20. if loopExist == True:

  21. slowPtr = head

  22. while slowPtr != fastPtr:

  23. fastPtr = fastPtr.next

  24. slowPtr = slowPtr.next

  25. return slowPtr

  26.  
  27. print("不是环结构")

  28. return False

  29.  
  30. if __name__ == "__main__":

  31. node1 = Node(1)

  32. node2 = Node(2)

  33. node3 = Node(3)

  34. node4 = Node(4)

  35. node5 = Node(5)

  36. node1.next = node2

  37. node2.next = node3

  38. node3.next = node4

  39. node4.next = node5

  40. node5.next = node2

  41. print(findbeginofloop(node1).item)

扩展问题:

判断两个单链表是否相交,如果相交,给出相交的第一个点(两个链表都不存在环)。

比较好的方法有两个:

一、将其中一个链表首尾相连,检测另外一个链表是否存在环,如果存在,则两个链表相交,而检测出来的依赖环入口即为相交的第一个点。

二、如果两个链表相交,那个两个链表从相交点到链表结束都是相同的节点,我们可以先遍历一个链表,直到尾部,再遍历另外一个链表,如果也可以走到同样的结尾点,则两个链表相交。

这时我们记下两个链表length,再遍历一次,长链表节点先出发前进(lengthMax-lengthMin)步,之后两个链表同时前进,每次一步,相遇的第一点即为两个链表相交的第一个点。

猜你喜欢

转载自blog.csdn.net/akunshouyoudou/article/details/88427170