力扣解题-160. 相交链表

力扣解题-160. 相交链表

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

图示两个链表在节点 c1 开始相交：

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

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

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

• intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
• listA - 第一个链表
• listB - 第二个链表
• skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
• skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数 评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。

在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Intersected at '2'

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [1,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

输出：No intersection

解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。

由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。

这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 1 <= m, n <= 3 * 10⁴
• 1 <= Node.val <= 10⁵
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

Related Topics

哈希表、链表、双指针

---

第一次解答

解题思路

核心方法：双指针相遇法（最优解），通过两个指针分别遍历两个链表，遍历完自身链表后切换到另一个链表的头节点继续遍历，最终两个指针会在相交节点相遇（或同时到达null），时间复杂度O(m+n)、空间复杂度O(1)，完美满足进阶要求，是本题最优雅、最高效的解法。

核心逻辑拆解

相交链表的核心难点是“两个链表长度不同，无法直接对齐遍历”，双指针法的巧妙之处在于让两个指针走相同长度的路径：

1. 路径设计：
   • 指针a：先遍历链表A，遍历完后从链表B的头节点开始遍历；
   • 指针b：先遍历链表B，遍历完后从链表A的头节点开始遍历；
2. 相遇原理：
   • 若链表相交：设链表A长度为m，链表B长度为n，相交部分长度为k，则指针a走的路径长度为m + (n - k)，指针b走的路径长度为n + (m - k)，两者相等，最终会在相交节点相遇；
   • 若链表不相交：两个指针会走完m + n个节点后同时到达null，此时循环终止，返回null；
3. 终止条件：当a == b时终止循环，此时a/b要么是相交节点，要么是null。

具体执行逻辑

1. 边界处理：若headA或headB为null，直接返回null（无相交可能）；
2. 初始化指针：创建指针a指向headA，指针b指向headB；
3. 循环遍历：当a != b时：
   • 若a为null，将a切换到headB；否则a向后走一步（a = a.next）；
   • 若b为null，将b切换到headA；否则b向后走一步（b = b.next）；
4. 返回结果：循环终止时，返回a（此时a == b，要么是相交节点，要么是null）。

执行流程可视化（以示例1为例）

步骤	指针a位置	指针b位置	操作说明
1	4(A头)	5(B头)	初始状态
2	1	6	各走一步
3	8	1	各走一步
4	4	8	各走一步
5	5	4	各走一步
6	null	5	a遍历完A，切换到B头
7	5(B头)	null	b遍历完B，切换到A头
8	6	4(A头)	各走一步
9	1	1	各走一步
10	8	8	a == b，终止循环，返回8

关键细节说明

• 指针切换时机：必须在指针为null时切换到另一个链表的头节点，而非遍历完链表后立即切换（保证路径长度相等）；
• 节点比较：比较的是节点的内存地址（引用），而非节点的值（题目明确说明值相同的节点可能不是同一个）；
• 原始结构保持：仅遍历链表，未修改任何节点的next指针，满足题目“保持原始结构”的要求；
• 时间/空间复杂度：
  • 时间：O(m+n)（最多遍历m+n个节点）；
  • 空间：O(1)（仅使用两个指针，无额外空间）。

性能说明

• 时间复杂度：O(m + n)（最优，需遍历两个链表各一次）；
• 空间复杂度：O(1)（仅使用常数级变量）；
• 优势：
  1. 完美满足进阶要求，时间和空间复杂度均为最优；
  2. 代码简洁优雅，无需计算链表长度、无需额外数据结构；
  3. 仅遍历一次，实际运行效率高。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if(headA==null || headB==null){
        return null;
    }
    ListNode a = headA;
    ListNode b = headB;
    while(a!=b){
        if(a==null){
            a=headB;
        }else {
            a=a.next;
        }
        if(b==null){
            b=headA;
        }else {
            b=b.next;
        }
    }
    return a;
}

---

示例解答

解题思路

解法1：哈希表法（直观版，O(m+n)时间+O(m)空间）

核心方法：先遍历一个链表，将所有节点存入哈希表，再遍历另一个链表，检查节点是否存在于哈希表中，第一个存在的节点即为相交节点，逻辑直观，易理解。

代码实现

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) {
        return null;
    }
    // 存储链表A的所有节点
    Set<ListNode> nodeSet = new HashSet<>();
    ListNode curr = headA;
    while (curr != null) {
        nodeSet.add(curr);
        curr = curr.next;
    }
    // 遍历链表B，检查节点是否在哈希表中
    curr = headB;
    while (curr != null) {
        if (nodeSet.contains(curr)) {
            return curr;
        }
        curr = curr.next;
    }
    // 无相交节点
    return null;
}

核心逻辑说明

1. 哈希表存储：遍历链表A，将每个节点的引用存入HashSet（保证O(1)时间查找）；
2. 检查相交：遍历链表B，逐个检查节点是否在HashSet中：
   • 第一个存在的节点即为相交节点（因为相交后所有节点都相同）；
   • 若遍历完B仍未找到，返回null；
3. 节点比较：HashSet存储的是节点引用，而非值，确保找到的是真正相交的节点。

性能说明

• 时间复杂度：O(m + n)（遍历A和B各一次）；
• 空间复杂度：O(m)（存储链表A的所有节点）；
• 优势：
  1. 逻辑直观，无需复杂的指针操作，易理解和实现；
  2. 代码可读性高，调试简单；
• 劣势：
  1. 空间复杂度O(m)，不满足进阶的O(1)空间要求；
  2. 哈希表有额外的存储和查找开销，效率略低于双指针法。

解法2：长度对齐法（O(m+n)时间+O(1)空间）

核心方法：先计算两个链表的长度，将较长链表的指针移动到与较短链表对齐的位置，再同时遍历两个链表，找到第一个相同的节点，逻辑清晰，易于调试。

代码实现

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) {
        return null;
    }
    // 计算链表长度
    int lenA = getLength(headA);
    int lenB = getLength(headB);
    
    // 对齐两个链表的起始位置
    ListNode currA = headA;
    ListNode currB = headB;
    if (lenA > lenB) {
        // A更长，移动A的指针
        currA = moveForward(currA, lenA - lenB);
    } else {
        // B更长，移动B的指针
        currB = moveForward(currB, lenB - lenA);
    }
    
    // 同时遍历，找相交节点
    while (currA != null && currB != null) {
        if (currA == currB) {
            return currA;
        }
        currA = currA.next;
        currB = currB.next;
    }
    // 无相交节点
    return null;
}

// 计算链表长度
private int getLength(ListNode head) {
    int len = 0;
    while (head != null) {
        len++;
        head = head.next;
    }
    return len;
}

// 将指针向前移动steps步
private ListNode moveForward(ListNode head, int steps) {
    while (steps > 0 && head != null) {
        head = head.next;
        steps--;
    }
    return head;
}

核心逻辑说明

1. 长度计算：分别遍历两个链表，计算长度lenA和lenB；
2. 指针对齐：将较长链表的指针向前移动|lenA - lenB|步，使两个指针到链表末尾的距离相等；
3. 同步遍历：同时移动两个指针，找到第一个相同的节点（相交节点），若遍历完仍未找到，返回null。

性能说明

• 时间复杂度：O(m + n)（计算长度遍历m+n次，对齐后遍历最多min(m,n)次，总O(m+n)）；
• 空间复杂度：O(1)（仅使用常数级变量）；
• 优势：
  1. 逻辑清晰，分步实现（计算长度→对齐→遍历），易于理解和调试；
  2. 满足进阶的O(1)空间要求；
• 劣势：
  1. 需要遍历链表两次（计算长度+对齐遍历），实际运行次数略多于双指针法；
  2. 代码量多于双指针法。

---

总结

1. 双指针相遇法（第一次解答）：O(m+n)时间+O(1)空间，最优解，代码简洁优雅，满足进阶要求，工程实践首选；
2. 哈希表法：O(m+n)时间+O(m)空间，逻辑直观，易实现，适合快速开发（不要求空间优化）；
3. 长度对齐法：O(m+n)时间+O(1)空间，逻辑清晰，易于调试，适合学习阶段理解核心思路；
4. 关键技巧：
   • 核心思想：相交链表的关键是“对齐遍历起点”，双指针法通过切换链表自动对齐，长度对齐法手动计算对齐；
   • 节点比较：必须比较节点引用而非值，避免值相同但地址不同的误判；
   • 性能选择：追求最优性能选双指针法，追求易理解选哈希表/长度对齐法。