[剑指Offer] 52_两个链表的第一个公共节点

题目

输入两个链表，找出它们的第一个公共节点。

例：

1->2->3
        \
          >6->7
        /
    4->5

公共节点为6。

---

思路

1. 遍历链表A，将每个节点存入一个哈希表。再遍历链表B，继续向哈希表内存储，当出现冲突时，即找到了第一个公共节点。
   1. 时间复杂度：O(m+n)
   2. 空间复杂度：O(m+n)
2. 遍历链表A，每个节点都在B中遍历查找，直到有一个A中节点能再B中找到。
   1. 时间复杂度：O(mn)
   2. 空间复杂度：O(1)
3. 遍历两个链表，记录长度，A = a + k，B = b + k，较长的链表先走|A-B|步，再同步走，第一个相同的节点即是。
   1. 时间复杂度：O(m+n)
   2. 空间复杂度：O(1)

---

代码

思路3：时间复杂度：O(m+n)，空间复杂度：O(1)

def first_common_nodes_in_lists(headA, headB):
    """
    :param headA: ListNode 1 head
    :param headB: ListNode 2 head
    :return: intersection node
    """
    if not headA or not headB:
        return None
    p1, p2 = headA, headB
    while p1 is not p2:
        p1 = p1.next if p1 else headB
        p2 = p2.next if p2 else headA
    return p1

---

思考

同样的思路但是书上的代码就没有这个我在LeetCode上看到的优雅。

1. 不使用额外变量储存长度，长度差在第一次遍历后交换链表头再继续遍历时自然消除。
2. 两链表无交点时，第二次遍历结束后将会p1 = p2 = None 返回None，自然表征。

LeetCode 160. 相交链表

题目

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。