LeetCode题练习与总结：相交链表--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
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

 

提示：

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

二、解题思路

要找出两个链表的相交点，可以使用双指针法。首先，分别计算两个链表的长度，得出它们的长度差 diff。然后，让较长的链表先走 diff 步，接着两个链表同时开始走，当两个链表的当前节点相同时，即为相交点。

以下是具体的步骤：

1. 分别计算两个链表的长度。
2. 找出较长的链表，并计算两个链表的长度差 diff。
3. 较长链表先走 diff 步。
4. 两个链表同时开始走，当两个链表的当前节点相同时，即为相交点。

三、具体代码

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 计算链表A的长度
        int lenA = 0;
        ListNode tempA = headA;
        while (tempA != null) {
            lenA++;
            tempA = tempA.next;
        }
        
        // 计算链表B的长度
        int lenB = 0;
        ListNode tempB = headB;
        while (tempB != null) {
            lenB++;
            tempB = tempB.next;
        }
        
        // 找出较长的链表，并计算长度差
        int diff = Math.abs(lenA - lenB);
        ListNode longer = lenA > lenB ? headA : headB;
        ListNode shorter = lenA > lenB ? headB : headA;
        
        // 较长链表先走diff步
        while (diff > 0) {
            longer = longer.next;
            diff--;
        }
        
        // 两个链表同时开始走，当两个链表的当前节点相同时，即为相交点
        while (longer != null && shorter != null) {
            if (longer == shorter) {
                return longer;
            }
            longer = longer.next;
            shorter = shorter.next;
        }
        
        // 如果没有相交点，返回null
        return null;
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 计算链表A的长度：需要遍历整个链表A，设链表A的长度为m，则这部分的时间复杂度为O(m)。
• 计算链表B的长度：需要遍历整个链表B，设链表B的长度为n，则这部分的时间复杂度为O(n)。
• 找出较长的链表，并计算长度差：这一步是常数时间操作，可以忽略不计。
• 较长链表先走diff步：这一步的时间复杂度为O(diff)，其中diff是两个链表长度的差值。
• 两个链表同时开始走，寻找相交点：在最坏的情况下，需要遍历剩余的较短链表的长度，设为min(m, n)，则这部分的时间复杂度为O(min(m, n))。
• 综上所述，总的时间复杂度为O(m + n)，因为m和n分别是两个链表的长度，且m + n是整个算法中最大的时间消耗。

2. 空间复杂度

• 除了输入的链表节点外，没有使用额外的数据结构来存储中间结果，因此空间复杂度为O(1)。

综合以上分析，该算法的时间复杂度为O(m + n)，空间复杂度为O(1)。

五、总结知识点

1. 链表的基本操作：代码中涉及了链表的遍历、节点值的访问、以及链表结构的移动（指针的移动）。

2. 循环语句：使用了while循环来进行链表的遍历和节点移动。

3. 常量变量：定义了临时变量（tempA, tempB）和计数变量（lenA, lenB, diff）来存储链表的长度和长度差。

4. 条件语句：使用了if条件语句来判断链表的长度，并决定哪个链表是较长的。

5. 数学函数：使用了Math.abs()函数来计算两个链表长度的绝对差值。

6. 指针（引用）的概念：在Java中，链表节点是通过引用（类似于C/C++中的指针）来访问和操作的。

7. 链表长度差的处理：通过让较长的链表先走长度差步数，使得两个链表在相交点之前对齐。

8. 相交链表的查找：通过同时遍历两个链表，比较当前节点是否相同来找到相交点。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。