LeetCode hot 100—相交链表

最新推荐文章于 2025-04-30 18:29:00 发布

rigidwill666

最新推荐文章于 2025-04-30 18:29:00 发布

阅读量996

点赞数 14

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签： leetcode 链表算法

本文链接：https://blog.youkuaiyun.com/rigidwill/article/details/146046582

leetcode 专栏收录该内容

87 篇文章

订阅专栏

题目

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

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

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

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

示例

示例 1：

输入：listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

输入：listA = [1,9,1,2,4], listB = [3,2,4]
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。

示例 3：

输入：listA = [2,6,4], listB = [1,5]
输出：No intersection
解释：这两个链表不相交，因此返回 null 。

分析

哈希集合法

遍历其中一个链表（如链表 A），将链表中每个节点的地址存储到一个哈希集合中。

接着遍历另一个链表（链表 B），对于链表 B 中的每个节点，检查其是否已经存在于哈希集合中。如果存在，那么这个节点就是两个链表相交的起始节点；如果遍历完都没有找到这样的节点，说明两个链表不相交，返回 null。

时间复杂度：O( $m+n$ )，其中 $m$ 和 $n$ 分别是链表 headA 和 headB 的长度

空间复杂度：O( $m$ )，其中 $m$ 是链表 headA 的长度

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 定义一个哈希集合，用于存储链表 A 中节点的地址
        std::unordered_set<ListNode*> nodeSet;
        // 遍历链表 A，将每个节点的地址存入哈希集合
        ListNode* currentA = headA;
        while (currentA != nullptr) {
            nodeSet.insert(currentA);
            currentA = currentA->next;
        }
        // 遍历链表 B，检查每个节点是否在哈希集合中
        ListNode* currentB = headB;
        while (currentB != nullptr) {
            if (nodeSet.count(currentB) > 0) {
                // 如果当前节点在哈希集合中，说明找到了相交节点
                return currentB;
            }
            currentB = currentB->next;
        }
        // 遍历完链表 B 都没找到相交节点，返回 nullptr
        return nullptr;
    }
};

双指针法

让两个指针 pA 和 pB 从两个链表的头节点开始遍历，当 pA 遍历完链表 A 后，让它从链表 B 的头节点开始继续遍历；同理，当 pB 遍历完链表 B 后，让它从链表 A 的头节点开始继续遍历。这样，如果两个链表相交，那么在某个时刻，pA 和 pB 会指向同一个节点，这个节点就是相交的起始节点；如果两个链表不相交，那么 pA 和 pB 最终都会指向 null。

数学推导

两个链表相交

指针 pA 走过的路程：指针 pA 先遍历链表 A 的不相交部分，长度为 a，再遍历相交部分，长度为 c，然后从链表 B 的头节点开始，遍历链表 B 的不相交部分，长度为 b。所以 pA 走过的总路程为 a + c + b

指针 pB 走过的路程：指针 pB 先遍历链表 B 的不相交部分，长度为 b，再遍历相交部分，长度为 c，然后从链表 A 的头节点开始，遍历链表 A 的不相交部分，长度为 a。所以 pB 走过的总路程为 b + c + a
这意味着在走过上述路程后，pA 和 pB 会在相交节点处相遇

两个链表不相交

指针 pA 走过的路程：pA 先遍历链表 A 的全部长度 a，然后遍历链表 B 的全部长度 b，总路程为 a + b

指针 pB 走过的路程：pB 先遍历链表 B 的全部长度 b，然后遍历链表 A 的全部长度 a，总路程为 b + a
这意味着在走过上述路程后，pA 和 pB 会同时到达链表的末尾（即 nullptr）

时间复杂度：O( $m+n$ )，其中 $m$ 和 $n$ 分别是链表 headA 和 headB 的长度

空间复杂度：O(1)

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 如果其中一个链表为空，直接返回 null
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        // 定义两个指针分别指向两个链表的头节点
        ListNode* pA = headA;
        ListNode* pB = headB;
        // 当 pA 和 pB 不相等时，继续遍历
        while (pA != pB) {
            // 如果 pA 遍历完链表 A，让它从链表 B 的头节点开始继续遍历
            pA = (pA == nullptr) ? headB : pA->next;
            // 如果 pB 遍历完链表 B，让它从链表 A 的头节点开始继续遍历
            pB = (pB == nullptr) ? headA : pB->next;
        }
        // 返回相交的起始节点，如果不相交则返回 null
        return pA;
    }
};