这道题 要想解决其实不难， 开两层循环进行遍历就能实现，但是会超时
如果想要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