這道題 要想解決其實不難， 開兩層循環進行遍歷就能實現，但是會超時

如果想要O(n) 的時間復雜度， 我考慮用哈希表來存儲遍歷過的元素，如果發現當前遍歷的元素在哈希表裏，那說明交叉點就在這

這裏利用了哈希表的查找時間是O(1)

但是這種算法不能滿足空間復雜度是O(1)的要求

代碼像這樣：

 1 class Solution(object):
 2     def getIntersectionNode(self, headA, headB):
 3         """
 4         :type head1, head1: ListNode
 5         :rtype: ListNode
 
 6         """
 7         # 如果有一個鏈表是空的 那就沒有交叉
 8         if headA is None or headB is None:
 9             return None
10         # 計算一下兩個鏈表的長度
11         ca = headA
12         cb = headB
13         ta, tb = 1, 1
14         while ca.next is not None:
15             ta += 1
16             ca = ca.next
 
17         while cb.next is not None:
18             tb += 1
19             cb = cb.next
20         # 如果最後一個元素都不一樣說明沒有交叉
21         if ca.val != cb.val:
22             return None
23         # 如果兩個鏈表長度不一樣，將長得鏈表指針後移
24         ca = headA
25         cb = headB
26         while tb > ta:
27             tb -= 1
28
 
             cb = cb.next
29         while ta > tb:
30             ta -= 1
31             ca = ca.next
32         # 從倒數長度相同的 短的鏈表的開頭開始一位一位比較
33         while ca is not None and cb is not None:
34             if ca.val == cb.val:
35                 return ca
36             ca = ca.next
37             cb = cb.next

經過一段時間思考，如果要滿足空間復雜度是O(1) 那就不能開辟新空間，智能用指針來回移動的辦法

1 如果任何一個鏈表是空的說明沒有交叉

2 如果鏈表交叉了最後一個元素肯定相同， 如果不相同說明沒交叉

3 如果確定了有交叉，計算一下兩個鏈表的長度，

　　思想是 調整到一樣長，然後按位比較 這樣一次遍歷就可以

　　具體這樣做： 每個鏈表都有一個遍歷指針，

　　　　短的鏈表的指針在頭部

　　　　長的鏈表指針後移若幹位，一直到 兩個鏈表從尾巴開始數 到遍歷指針的長度是相同的

　　　　接下來就一遍遍歷 每一位都比較一下是否相等就可以

　　這樣沒有開辟新的空間 時間上是一遍遍歷O(n)

 1 class Solution(object):
 2     def getIntersectionNode(self, headA, headB):
 3         """
 4         :type head1, head1: ListNode
 5         :rtype: ListNode
 6         """
 7         # 建立一個哈希表，把每個第一次遍歷到的元素存進去
 8         # 如果發現之前存過當前元素說明交叉了
 9         dic = {}
10         ca = headA
11         cb = headB
12         while ca is not None or cb is not None:
13             if ca is not None:
14                 try:
15                     dic[ca.val]
16                     return ca
17                 except:
18                     dic[ca.val] = True
19                     ca = ca.next
20             if cb is not None:
21                 try:
22                     dic[cb.val]
23                     return cb
24                 except:
25                     dic[cb.val] = True
26                     cb = cb.next
27         return None

leetcode 相交鏈表 python實現