哈希表题目：相交链表

题目

标题和出处

标题：相交链表

出处：160. 相交链表

难度

2 级

题目描述

要求

给你两个单链表的头结点 $\text{headA}$ 和 $\text{headB}$，请你找出并返回两个单链表相交的起始结点。如果两个链表不存在相交结点，返回 $\text{null}$。

图示两个链表在结点 $\text{c1}$ 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

自定义评测：

评测系统的输入如下（你设计的程序不适用此输入）：

• $\text{intersectVal}$——相交的起始结点的值。如果不存在相交结点，这一值为 $\text{0}$。
• $\text{listA}$——第一个链表。
• $\text{listB}$——第二个链表。
• $\text{skipA}$——在 $\text{listA}$ 中（从头结点开始）跳到交叉结点的结点数。
• $\text{skipB}$——在 $\text{listB}$ 中（从头结点开始）跳到交叉结点的结点数。

评测系统将根据这些输入创建链式数据结构，并将两个头结点 $\text{headA}$ 和 $\text{headB}$ 传递给你的程序。如果程序能够正确返回相交结点，那么你的解决方案将被视作正确答案。

示例

示例 1：

输入：$\text{intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3}$
输出：$\text{Intersected at ‘8’}$
解释：相交结点的值为 $\text{8}$（注意，如果两个链表相交则不能为 $\text{0}$）。
从各自的表头开始算起，链表 $\text{A}$ 为 $\text{[4,1,8,4,5]}$，链表 $\text{B}$ 为 $\text{[5,6,1,8,4,5]}$。
在 $\text{A}$ 中，相交结点前有 $\text{2}$ 个结点；在 $\text{B}$ 中，相交结点前有 $\text{3}$ 个结点。

示例 2：

输入：$\text{intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1}$
输出：$\text{Intersected at ‘2’}$
解释：相交结点的值为 $\text{2}$（注意，如果两个链表相交则不能为 $\text{0}$）。
从各自的表头开始算起，链表 $\text{A}$ 为 $\text{[1,9,1,2,4]}$，链表 $\text{B}$ 为 $\text{[3,2,4]}$。
在 $\text{A}$ 中，相交结点前有 $\text{3}$ 个结点；在 $\text{B}$ 中，相交结点前有 $\text{1}$ 个结点。

示例 3：

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

数据范围

• $\text{listA}$ 中结点数目为 $\text{m}$
• $\text{listB}$ 中结点数目为 $\text{n}$
• $\text{1}\le \text{m, n}\le \text{3}\times {\text{10}}^{\text{4}}$
• $\text{1}\le \text{Node.val}\le {\text{10}}^{\text{5}}$
• $\text{0}\le \text{skipA}\le \text{m}$
• $\text{0}\le \text{skipB}\le \text{n}$
• 如果 $\text{listA}$ 和 $\text{listB}$ 没有交点，$\text{intersectVal}$ 为 $\text{0}$
• 如果 $\text{listA}$ 和 $\text{listB}$ 有交点，$\text{intersectVal}=\text{listA[skipA]}=\text{listB[skipB]}$

进阶

你能否设计一个时间复杂度 $\text{O(m + n)}$、空间复杂度 $\text{O(1)}$ 的解法？

解法一

思路和算法

如果两个链表相交，则一定存在一个相交的起始结点，从链表相交的起始结点到链表末尾结点的全部结点是两个链表共用的结点。遍历两个链表各一次，则两个链表共用的结点会被重复访问，第一个被重复访问的结点即为链表相交的起始结点。

如果两个链表不相交，则不存在两个链表共用的结点。遍历两个链表各一次，任何结点都不会被重复访问。

因此可以遍历两个链表各一次，根据是否有结点被重复访问判断两个链表是否相交。为了判断是否有结点被重复访问，可以使用哈希集合存储访问过的结点。

首先遍历链表 $\text{listA}$，将每个结点加入哈希集合，然后遍历链表 $\text{listB}$，对于链表 $\text{listB}$ 中遍历到的每个结点判断是否在哈希集合中。在遍历链表 $\text{listB}$ 的过程中遇到的第一个在哈希集合中的结点即为链表相交的起始结点，返回该结点。如果遍历链表 $\text{listB}$ 结束之后仍没有遇到在哈希集合中的结点，则两个链表不相交，返回 $\text{null}$。

代码

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> visited = new HashSet<ListNode>();
        ListNode temp = headA;
        while (temp != null) {
            visited.add(temp);
            temp = temp.next;
        }
        temp = headB;
        while (temp != null) {
            if (visited.contains(temp)) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }
}

复杂度分析

• 时间复杂度：$O(m+n)$，其中 $m$ 和 $n$ 分别是链表 $\text{listA}$ 和 $\text{listB}$ 的结点数。需要遍历两个链表各一次。

• 空间复杂度：$O(m)$，其中 $m$ 是链表 $\text{listA}$ 的长度。需要使用哈希集合存储链表 $\text{listA}$ 中的全部结点。

解法二

思路和算法

解法一使用哈希表，空间复杂度是 $O(m)$。使用双指针可以将空间复杂度降低到 $O(1)$。

创建两个指针 ${\text{pointer}}_1$ 和 ${\text{pointer}}_2$，指针 ${\text{pointer}}_1$ 依次遍历链表 $\text{listA}$ 和链表 $\text{listB}$ 的每个结点，指针 ${\text{pointer}}_2$ 依次遍历链表 $\text{listB}$ 和链表 $\text{listA}$ 的每个结点，初始时分别指向两个链表的头结点 $\text{headA}$ 和 $\text{headB}$。

指针 ${\text{pointer}}_1$ 的遍历过程是：从 $\text{headA}$ 开始依次遍历链表 $\text{listA}$ 的每个结点，当遍历完链表 $\text{listA}$ 之后，${\text{pointer}}_1$ 指向 $\text{null}$，下一步 ${\text{pointer}}_1$ 指向 $\text{headB}$，然后依次遍历链表 $\text{listB}$ 的每个结点，当遍历完链表 $\text{listB}$ 之后，${\text{pointer}}_1$ 指向 $\text{null}$。

指针 ${\text{pointer}}_2$ 的遍历过程和指针 ${\text{pointer}}_1$ 的遍历过程相似，区别在于指针 ${\text{pointer}}_2$ 先遍历链表 $\text{listB}$ 后遍历链表 $\text{listA}$。

两个指针的遍历同步进行，每次两个指针同时移动，直到两个指针指向同一个结点或者同时指向 $\text{null}$。

• 如果两个指针指向同一个结点，则该结点即为链表相交的起始结点，返回该结点。

• 如果两个指针同时指向 $\text{null}$，则两个链表不相交，返回 $\text{null}$。

证明

双指针解法的正确性证明需要考虑两种情况，第一种情况是两个链表相交，第二种情况是两个链表不相交。

如果两个链表相交，假设两个链表在相交之前的部分各有 $x$ 个结点和 $y$ 个结点，共用的部分有 $z$ 个结点，则 $x+z=m$，$y+z=n$，其中 $m$ 和 $n$ 分别是链表 $\text{listA}$ 和 $\text{listB}$ 的结点数。

• 如果 $x=y$，则两个指针同时到达链表相交的起始结点。

• 如果 $x\ne y$，则指针 ${\text{pointer}}_1$ 从 $\text{headA}$ 开始移动 $m+y+1$ 次之后到达链表相交的起始结点（从 $\text{null}$ 移动到 $\text{headB}$ 也是一次移动），指针 ${\text{pointer}}_2$ 从 $\text{headB}$ 开始移动 $n+x+1$ 次之后到达链表相交的起始结点（从 $\text{null}$ 移动到 $\text{headA}$ 也是一次移动），由于 $m+y+1=n+x+1=x+y+z+1$，因此两个指针同时到达链表相交的起始结点。

如果两个链表不相交，则两个指针一定会在移动相同次数之后同时指向 $\text{null}$。

• 如果 $m=n$，则两个链表的结点数相同，两个指针遍历两个链表同时结束，因此同时指向 $\text{null}$。

• 如果 $m\ne n$，则指针 ${\text{pointer}}_1$ 从 $\text{headA}$ 开始移动 $m+n+1$ 次之后指向 $\text{null}$（从 $\text{null}$ 移动到 $\text{headB}$ 也是一次移动），指针 ${\text{pointer}}_2$ 从 $\text{headA}$ 开始移动 $n+m+1$ 次之后指向 $\text{null}$（从 $\text{null}$ 移动到 $\text{headA}$ 也是一次移动），由于 $m+n+1=n+m+1$，因此两个指针同时指向 $\text{null}$。

代码

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pointer1 = headA, pointer2 = headB;
        while (pointer1 != pointer2) {
            pointer1 = pointer1 == null ? headB : pointer1.next;
            pointer2 = pointer2 == null ? headA : pointer2.next;
        }
        return pointer1;
    }
}

复杂度分析

• 时间复杂度：$O(m+n)$，其中 $m$ 和 $n$ 分别是链表 $\text{listA}$ 和 $\text{listB}$ 的结点数。最坏情况下，每个指针遍历两个链表各一次。

• 空间复杂度：$O(1)$。