前言

有Python基础

有数据结构单链表基础，没接触过的可以看下面链接

https://blog.csdn.net/sf9898/article/details/104946291

原理和实现

有一个链表，但是我们不知道这个链表是否内部有形成一个环(形成回路)，因此需要有一个函数来检测是否有环(由此可知，这个函数的返回值应是布尔型)。

先去继承一下单链表的蚂蚁花呗(属性和方法)，详见链接：https://blog.csdn.net/sf9898/article/details/104946291 将单链表的定义拷贝下来。

直接可以做测试，构建一个链表(或许有环，这一部分先写没环的)，代码如下：

ll = Link()

# 先构建测试用的链表

for i in range(5):

ll.addFront(i)

ll.addFront(100)

ll.addBack(250)

for i in range(5):

ll.addBack(i)

# 到目前为止是一串没有环的链表

ll.travel() # 100 4 3 2 1 0 250 0 1 2 3 4

在代码中加入了几个明显与其他成员格格不入的data，这样子也更容易区分下。

接下来构建有环的链表，设置一个函数getLastNode使得我们可以取到链表的最后一个节点(这个例子中就是4这个节点)，然后将它的next指向250的这个节点(又要有个函数能够取到这个节点，因此有了getNode这个函数)，这样就可以形成环了。效果大致如下图。

# class Link的方法

def getLastNode(self):

cur = self.__head

pre = None

while cur:

pre = cur

cur = cur.next

return pre

def getNode(self, item):

cur = self.__head

res = None

while cur:

if cur.item == item:

res = cur

break

else:

cur = cur.next

return res

ll = Link()

# 先构建测试用的链表

for i in range(5):

ll.addFront(i)

ll.addFront(100)

ll.addBack(250)

for i in range(5):

ll.addBack(i)

# 到目前为止是一串没有环的链表

ll.travel() # 100 4 3 2 1 0 250 0 1 2 3 4

# 接下来构建有环的链表

# 设置一个函数getLastNode使得我们可以取到链表的最后一个节点(这个例子中就是4这个节点)，

# 然后将它的next指向250的这个节点(又要有个函数能够取到这个节点，因此有了getNode这个函数)，这样就可以形成环了

# print(ll.getNode(250).item) # 这一行用来验证getNode 函数的正确性，应打印250

ll.getLastNode().next = ll.getNode(250)

ll.travel() # 事实上现在遍历一下就可以发现事情不简单了

既然是要写一个函数来判断，那建议还是将这个函数写成class Link的方法。

def hasLoop(self):

if self.__head is None:

return False

# 能到这说明头结点不是空的，但是有可能只有一个节点，也有可能 N个(N > 1)

aNode = self.__head

bNode = self.__head

res = False

# 2个结点，往前跑，一个跑的快，一个跑的慢，如果没有环，慢的结点不会追上快的

# 如果有环，肯定有一个时刻，快的点绕回来追上了慢的点

# 如果只有一个或两个结点，则不会进行下面的循环，直接返回False (res)

while bNode.next and bNode.next.next:

bNode = bNode.next.next # 这里用B结点代表跑的快的，A是跑的慢的

aNode = aNode.next

if bNode == aNode:

res = True

break

return res

测试一下，完整代码：

class Node(object):

def __init__(self, item):

self.item = item

self.next = None

class Link(object):

def __init__(self):

self.__head = None

def isEmpty(self):

return self.__head is None

# 头部插入

def addFront(self, item):

node = Node(item)

node.next = self.__head

self.__head = node

# 尾部插入

def addBack(self, item):

node = Node(item)

if self.__head is None:

self.__head = node

return

cur = self.__head

pre = None

while cur:

pre = cur

cur = cur.next

# 当cur 为最后一个节点时带入，pre更新为最后一个节点，cur更新为最后一个节点的下一个节点即为空，

# 下一次while cur 时会退出循环，此时的pre表示的就是最后一个节点，将node挂到pre的后面即可

pre.next = node

def size(self):

count = 0

cur = self.__head

while cur:

count += 1

cur = cur.next

return count

def travel(self):

cur = self.__head

while cur:

print(cur.item, end=' ')

cur = cur.next

print('')

# 删除头部节点

def removeFront(self):

cur = self.__head

self.__head = self.__head.next

cur.next = None

# 删除尾部节点

def removeBack(self):

# 空节点时

if self.__head is None:

return

# 只有一个节点

if self.__head and self.__head.next is None:

self.__head = None

return

# 链表节点有两个及以上

cur = self.__head # 当前节点

pre = None # 前一个节点

cn = cur.next # 后一个节点

# 刚开始cur取到的是第一个节点，cn是第二个

while cn:

pre = cur

cur = cur.next

cn = cur.next

pre.next = None

def getLastNode(self):

cur = self.__head

pre = None

while cur:

pre = cur

cur = cur.next

return pre

def getNode(self, item):

cur = self.__head

res = None

while cur:

if cur.item == item:

res = cur

break

else:

cur = cur.next

return res

def hasLoop(self):

if self.__head is None:

return False

# 能到这说明头结点不是空的，但是有可能只有一个节点，也有可能 N个(N > 1)

aNode = self.__head

bNode = self.__head

res = False

# 2个结点，往前跑，一个跑的快，一个跑的慢，如果没有环，慢的结点不会追上快的

# 如果有环，肯定有一个时刻，快的点绕回来追上了慢的点

# 如果只有一个或两个结点，则不会进行下面的循环，直接返回False

while bNode.next and bNode.next.next:

bNode = bNode.next.next # 这里用B结点代表跑的快的，A是跑的慢的

aNode = aNode.next

if bNode == aNode:

res = True

break

return res

ll = Link()

# 先构建测试用的链表

for i in range(5):

ll.addFront(i)

ll.addFront(100)

ll.addBack(250)

for i in range(5):

ll.addBack(i)

# 到目前为止是一串没有环的链表

ll.travel() # 100 4 3 2 1 0 250 0 1 2 3 4

# 接下来构建有环的链表

# 设置一个函数getLastNode使得我们可以取到链表的最后一个节点(这个例子中就是4这个节点)，

# 然后将它的next指向250的这个节点(又要有个函数能够取到这个节点，因此有了getNode这个函数)，这样就可以形成环了

# print(ll.getNode(250).item) # 这一行用来验证getNode 函数的正确性，应打印250

ll.getLastNode().next = ll.getNode(250)# 注释掉这行，就无法形成环了，这时下面的打印结果应是False

# ll.travel() # 事实上现在遍历一下就可以发现事情不简单了

print(ll.hasLoop())

结果

后面发现这样其实是不严谨的，当节点数为2的时候，并且第二个node的next指向第一个，这个时候也算是一个环，在上面的代码中吧这种情况当做不是环。为了实现这个要求，需要对上面的代码进行修改。

def hasLoop(self):

if self.__head is None:

return False

# 能到这说明头结点不是空的，但是有可能只有一个节点，也有可能 N个(N > 1)

if self.__head and self.__head.next is None:

# 只有一个头结点，不认为是环

return False

# 能到这里就说明，至少有2个节点了

# 有两个及以上结点，这里第二个节点的next指向None可以说明没有环，否则这里就有可能会出现环

if self.__head.next.next == self.__head:

# 如果第二个节点的next指向第一个节点则认为是环，否则可能是指向空或者是下一个节点

return True

aNode = self.__head

bNode = self.__head

res = False

# 设置2个结点，往前跑，一个跑的快，一个跑的慢，如果没有环，慢的结点不会追上快的

# 如果有环，肯定有一个时刻，快的点绕回来追上了慢的点

# 如果只有两个结点(也就是说第二个节点的next指向None)，则不会进行下面的循环，直接返回False

while bNode.next and bNode.next.next:

bNode = bNode.next.next # 这里用B结点代表跑的快的，A是跑的慢的

aNode = aNode.next

if bNode == aNode:

res = True

break

return res

完整代码：

class Node(object):

def __init__(self, item):

self.item = item

self.next = None

class Link(object):

def __init__(self):

self.__head = None

def isEmpty(self):

return self.__head is None

# 头部插入

def addFront(self, item):

node = Node(item)

node.next = self.__head

self.__head = node

# 尾部插入

def addBack(self, item):

node = Node(item)

if self.__head is None:

self.__head = node

return

cur = self.__head

pre = None

while cur:

pre = cur

cur = cur.next

# 当cur 为最后一个节点时带入，pre更新为最后一个节点，cur更新为最后一个节点的下一个节点即为空，

# 下一次while cur 时会退出循环，此时的pre表示的就是最后一个节点，将node挂到pre的后面即可

pre.next = node

def size(self):

count = 0

cur = self.__head

while cur:

count += 1

cur = cur.next

return count

def travel(self):

cur = self.__head

while cur:

print(cur.item, end=' ')

cur = cur.next

print('')

# 删除头部节点

def removeFront(self):

cur = self.__head

self.__head = self.__head.next

cur.next = None

# 删除尾部节点

def removeBack(self):

# 空节点时

if self.__head is None:

return

# 只有一个节点

if self.__head and self.__head.next is None:

self.__head = None

return

# 链表节点有两个及以上

cur = self.__head # 当前节点

pre = None # 前一个节点

cn = cur.next # 后一个节点

# 刚开始cur取到的是第一个节点，cn是第二个

while cn:

pre = cur

cur = cur.next

cn = cur.next

pre.next = None

def getLastNode(self):

cur = self.__head

pre = None

while cur:

pre = cur

cur = cur.next

return pre

def getNode(self, item):

cur = self.__head

res = None

while cur:

if cur.item == item:

res = cur

break

else:

cur = cur.next

return res

def hasLoop(self):

if self.__head is None:

return False

# 能到这说明头结点不是空的，但是有可能只有一个节点，也有可能 N个(N > 1)

if self.__head and self.__head.next is None:

# 只有一个头结点，不认为是环

return False

# 能到这里就说明，至少有2个节点了

# 有两个及以上结点，这里第二个节点的next指向None可以说明没有环，否则这里就有可能会出现环

if self.__head.next.next == self.__head:

# 如果第二个节点的next指向第一个节点则认为是环，否则可能是指向空或者是下一个节点

return True

aNode = self.__head

bNode = self.__head

res = False

# 设置2个结点，往前跑，一个跑的快，一个跑的慢，如果没有环，慢的结点不会追上快的

# 如果有环，肯定有一个时刻，快的点绕回来追上了慢的点

# 如果只有两个结点(也就是说第二个节点的next指向None)，则不会进行下面的循环，直接返回False

while bNode.next and bNode.next.next:

bNode = bNode.next.next # 这里用B结点代表跑的快的，A是跑的慢的

aNode = aNode.next

if bNode == aNode:

res = True

break

return res

ll = Link()

# # 先构建测试用的链表

# for i in range(5):

# ll.addFront(i)

# ll.addFront(100)

# ll.addBack(250)

# for i in range(5):

# ll.addBack(i)

# # 到目前为止是一串没有环的链表

# ll.travel() # 100 4 3 2 1 0 250 0 1 2 3 4

# # 接下来构建有环的链表

# # 设置一个函数getLastNode使得我们可以取到链表的最后一个节点(这个例子中就是4这个节点)，

# # 然后将它的next指向250的这个节点(又要有个函数能够取到这个节点，因此有了getNode这个函数)，这样就可以形成环了

#

# # print(ll.getNode(250).item) # 这一行用来验证getNode 函数的正确性，应打印250

#

# # ll.getLastNode().next = ll.getNode(250)

# # ll.travel() # 事实上现在遍历一下就可以发现事情不简单了

# print(ll.hasLoop())

# 一种特殊的情况，只有两个结点，但是形成环

ll.addBack(1)

ll.addBack(2)

ll.getLastNode().next = ll.getNode(1)

print(ll.hasLoop())# 现在结果应该是True

结果