leetcode 相交链表 python实现

Posted 2021-01-04 稀里糊涂林老冷

 

这道题 要想解决其实不难， 开两层循环进行遍历就能实现，但是会超时

 

如果想要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