判断单向列表是否有环（Python）

 

例如上图一个有环结构的链表，可以通过快慢指针的思路进行判断是否有环

两个指向头节点的指针，fast和slow，一起从头结点开始往后遍历，fast每次移动两个结点，slow每次移动一个结点

若存在环结构，那么fast指针在不断绕环的过程中肯定会找到slow指针

class Node():
#定义一个Node类，构造两个属性，一个是item节点值，另一个是节点的下一个指向
    def __init__(self, item=None):
        self.item = item
        self.next = None
def findbegin(head):
    slowPtr = head     #将头节点赋予slowPtr
    fastPtr =head       #将头节点赋予fastPtr
    loopExist = False  #默认环不存在
    if head = None:
        return False
    while fastPtr.next != None and fastPtr.next.next != None: #fastPtr的下一个节点和下下个节点都不为空
        solwPtr = solwPtr.next       #slowPtr每次移动一个节点
        fastPtr = fastPtr.next.next  #fastPtr每次移动一个节点
        if slowPtr = fastPtr:
            loopExist = True
            print("存在环结构“)
            break
    if loopExist == True:
        slowPtr = head
        while solwPtr != fastPtr:
            fastPtr = fastPtr.next
            slowPtr = solwPtr.next
        return slowPtr
     print("不是环结构")
     return False

 if __name__ == "__main__":
     node1 = Node(1)
     node2 = Node(2)
     node3 = Node(3)
     node4 = Node(4)
     node5 = Node(5)
     node1.next = node2
     node2.next = node3
     node3.next = node4
     node4.next = node5
     node5.next = node2
     print(findbeginofloop(node1).item)

时间复杂度为O(n)，空间复杂度为O(1)，实际使用两个指针。

相应的，我们可以采用这种思路解决leetcode160题，相交链表

两个链表分别从开始遍历，一条遍历到空而另一条还未为空时，将遍历到空的链表跳到另一条链表的开头继续遍历，如此反复，总会相遇。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        p1 = headA
        p2 = headB

        while p1 != p2:
            if not p1:      #如果p1为空
                p1 = headB
            else:
                p1 = p1.next
            if not p2:
                p2 = headA
            else:
                p2 = p2.next
        return p2

 

参考

https://www.cnblogs.com/kunpengv5/p/7784791.html