[路飞]_一起刷leetcode 面试题 02.07. 链表相交

「这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」

题目

面试题 02.07. 链表相交

难度简单114收藏分享切换为英文接收动态反馈

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

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

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

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

示例 1：

输入： intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出： Intersected at '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
输出： Intersected at '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 。
复制代码

提示：

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

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

思路

这道题目看起来很长，设计总结一下就是判断两个链表有没有共同元素;
我们可以用Map记录A链表中的每一个元素，然后遍历B链表中判断元素是否在Map出现过。

实现

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    if(!headA || !headB) {
        return null;
    }

    let map = new Map();

    while (headA) {
        map.set(headA);
        headA = headA.next;
    }

    while (headB) {
        if (map.has(headB)) {
            return headB;
        }
        headB = headB.next;
    }

    return null;
};
复制代码

优化

题目进阶中提到，使用额外空间O(1)来做，所以我们只能放弃用Map;
我们可以改用双指针来做，让currentA指针从A链表出发，跑完A链表跑B链表;
让currentB指针从B链表出发，跑完B链表跑A链表；

那么结果可能有三种情况：

这是第一种情况，交点刚好就出现在正中间，那我们第三个元素就能相遇，直接返回节点；

这是第二种情况， currentA 跑完 A链表，再经过b段到达 C1 节点的时候，总共跑的路径为 a+b+c，而currentB 跑完 B链表，再经过a段到达C1节点的时候，总共跑的路径为 b+c+a, 我们可以发现如果存在交点，那么跑第二个链表的时候它们两个必然会相遇；

这是第三种情况，两者没有焦点，那么两者跑完两个链表的时间，都是一样的。这时候两者总会都等于null。

优化代码

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    if(!headA || !headB) {
        return null;
    }

    let currentA = headA;
    let currentB = headB;

    while(currentA !== currentB) {
        currentA = currentA ? currentA.next : headB;
        currentB = currentB ? currentB.next : headA;
    }

    return currentA;
};
复制代码

看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式，有好的建议欢迎评论区留言。