例如上圖一個有環結構的連結串列，可以通過快慢指標的思路進行判斷是否有環

兩個指向頭節點的指標，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