（Python3）数据结构——07.单链表之判断链表是否有环

最新推荐文章于 2024-05-10 10:20:29 发布

1、、

最新推荐文章于 2024-05-10 10:20:29 发布

阅读量570

点赞数

分类专栏： python3数据结构文章标签：链表数据结构 python 算法单链表

本文链接：https://blog.csdn.net/sf9898/article/details/104989797

版权

python3数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

前言

有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