（Python3）数据结构——07.单链表之判断链表是否有环
前言
- 有Python基础
- 有数据结构单链表基础，没接触过的可以看下面链接
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
- 结果
