力扣最热一百题——相交链表

已于 2024-09-16 14:48:16 修改
阅读量1.7k 收藏 43
点赞数 40
分类专栏： 我的算法记录 文章标签： leetcode 链表 算法 双指针 哈希表
于 2024-09-12 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DDDDWJDDDD/article/details/142107127
版权

题目链接：160. 相交链表 - 力扣（LeetCode）

注：下述题目描述和示例均来自力扣

题目描述

        给你两个单链表的头节点 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]

解法一：双重遍历寻找相同地址

实现思路

这段代码的思路是通过双重循环遍历两个链表，逐个比较每个节点的地址来寻找相交节点。

  1. 特殊情况处理：首先检查输入的两个链表是否为空。如果其中一个链表为空，显然它们不可能相交，直接返回 null。

  2. 初始化指针：将两个指针 a 和 b 分别指向链表A和链表B的头节点，用于遍历链表。

  3. 遍历逻辑：

    • 外层循环遍历链表A的每个节点。
    • 内层循环遍历链表B的每个节点。
    • 在内层循环中，如果节点 a 和节点 b 的地址相同（即它们引用的是同一个节点），则表示找到了相交节点，记录这个节点并退出循环。

  4. 重新遍历链表B：当链表B被遍历完没有找到相交节点时，指针 a 后移一个节点，指针 b 重新回到链表B的起点，继续外层循环。

  5. 终止条件：如果找到了相交节点，标志位 flag 变为 false，立即结束循环。如果遍历完所有节点也没有找到相交节点，则返回 null。

        通过暴力的双重循环遍历，逐一比较链表A的每个节点与链表B的每个节点，找到它们的第一个公共节点（相交节点）。

Java代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 如果链表本来就是空的那么肯定没有相交的节点
        if (headA == null || headB == null){
            return null;
        }
        ListNode a = headA;
        ListNode b = headB;
        ListNode resNode = null;
        // 定义信号位用于判断是否出现了相交节点
        boolean flag = true;
        // 判断a是否遍历完了
        while (flag && a != null){
            // 判断b是否遍历完了
            while (flag && b != null){
                // 这里的a和b都是地址，如果地址是同一个那么意味着就是相交节点
                if (a == b){
                    resNode = a;
                    flag = false;
                }else {
                    // 不是那就让b下一位
                    b = b.next;
                }
            }
            if (!flag){
                break;
            }
            // 如果b被遍历完了都没有找到那么久a后移，然后b重新定位到开头
            if (b == null){
                a = a.next;
                b = headB;
            }
        }
        return resNode;
    }
}

C++代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(nullptr) {}
 * };
 */

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 如果链表本来就是空的那么肯定没有相交的节点
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }

        ListNode *a = headA;
        ListNode *b = headB;
        ListNode *resNode = nullptr;
        // 定义信号位用于判断是否出现了相交节点
        bool flag = true;

        // 判断a是否遍历完了
        while (flag && a != nullptr) {
            // 判断b是否遍历完了
            while (flag && b != nullptr) {
                // 这里的a和b都是地址，如果地址是同一个那么意味着就是相交节点
                if (a == b) {
                    resNode = a;
                    flag = false;
                } else {
                    // 不是那就让b下一位
                    b = b->next;
                }
            }

            if (!flag) {
                break;
            }

            // 如果b被遍历完了都没有找到那么a后移，然后b重新定位到开头
            if (b == nullptr) {
                a = a->next;
                b = headB;
            }
        }

        return resNode;
    }
};

使用时间

解法二：哈希表

实现思路

  1. 特殊情况处理：首先判断两个链表是否为空。如果任意一个链表为空，那么它们不可能相交，直接返回 null。

  2. 遍历链表A并存储节点：将链表A的所有节点存入一个哈希表中。因为哈希表的查找时间复杂度是 O(1)，这一步的目的是为了快速判断链表B的节点是否存在于链表A中。

  3. 遍历链表B：遍历链表B的每个节点，检查该节点是否存在于哈希表中。如果存在，说明找到了两个链表的相交节点，直接返回该节点。

  4. 返回结果：如果遍历完链表B后，仍未找到任何相交节点，则返回 null。

        通过这种方式，算法有效地利用了哈希表的快速查找能力来减少时间复杂度。整个过程的时间复杂度是 O(N + M)，其中 N 是链表A的长度，M 是链表B的长度。

Java代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 如果链表本来就是空的那么肯定没有相交的节点
        if (headA == null || headB == null){
            return null;
        }
        ListNode a = headA;
        ListNode b = headB;
        // 利用哈希表存储a中的值
        Set<ListNode> setA = new HashSet<>();
        // 将链表a的值全部存入哈希表
        while (a != null){
            setA.add(a);
            a = a.next;
        }
        // 遍历B看a中是否有和b相同的点位（地址）
        while (b != null){
            if (setA.contains(b)) {
                return b;
            }else {
                b = b.next;
            }
        }
        // 没找到返回null
        return null;
    }
}

C++代码实现

#include <unordered_set>

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(nullptr) {}
 * };
 */

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 如果链表本来就是空的那么肯定没有相交的节点
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }

        ListNode *a = headA;
        ListNode *b = headB;
        
        // 利用哈希表存储a中的节点地址
        std::unordered_set<ListNode*> setA;
        
        // 将链表A中的节点全部存入哈希表
        while (a != nullptr) {
            setA.insert(a);
            a = a->next;
        }
        
        // 遍历链表B，查找是否有相同节点
        while (b != nullptr) {
            if (setA.find(b) != setA.end()) {
                return b;  // 找到相交节点
            } else {
                b = b->next;
            }
        }
        
        // 没找到返回nullptr
        return nullptr;
    }
};

使用时间

解法三：双指针

实现思路

一句话，你没发现这个两个链表是互补的吗？？

给A链表增加B链表的长度，给B链表增加A链表的长度

这样他俩就一样了，那么我们让他们走一样了路程了，那一刻，那个位置

不就刚好是相交的位置吗，完美至极！！！

 具体大家可以看看官方题解的说明，说的比我详细，但是我属于是一语道破天机嘿嘿

  1. 特殊情况处理：首先检查两个链表是否为空。如果任意一个链表为空，直接返回 null，因为链表为空不可能有相交节点。

  2. 双指针初始化：定义两个指针 A 和 B，分别指向链表A和链表B的头节点。

  3. 双指针遍历链表：两个指针同时向前遍历。如果 A 指针到达链表A的末尾，则将其重新指向链表B的头节点；同样，如果 B 指针到达链表B的末尾，则将其重新指向链表A的头节点。

  4. 相交节点判断：通过这种指针交换的方式，最终 A 和 B 将在相交点相遇。如果两个链表存在相交节点，指针 A 和 B 最终会指向相同的节点；如果没有相交节点，它们最终都会变为 null，结束循环。

  5. 返回结果：当 A 和 B 相等时，说明找到了相交节点，直接返回。如果遍历结束仍未相等，则说明没有相交节点，返回 null。

        这种方法的时间复杂度是 O(N + M)，其中 N 和 M 分别是两个链表的长度。通过让两个指针走过相同的总长度，实现了同时到达相交节点或结束。

Java代码实现

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode A = headA, B = headB;
        while (A != B) {
            A = A == null ? headB : A.next;
            B = B == null ? headA : B.next;
        }
        return A;
    }
}

C++代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(nullptr) {}
 * };
 */

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        
        ListNode *A = headA;
        ListNode *B = headB;

        // 当A和B不相等时，遍历两个链表
        while (A != B) {
            // 如果A遍历到链表尾端，重定向到链表B的头部
            A = A == nullptr ? headB : A->next;
            // 如果B遍历到链表尾端，重定向到链表A的头部
            B = B == nullptr ? headA : B->next;
        }
        
        // 当A == B时，返回相交节点或nullptr（如果无相交）
        return A;
    }
};

使用时间

总结

        从直接暴力的思路到采用哈希表优化到发现两个链表的互补关系，我们拿下了全世界99.91%的人，我们太强了！！！！！！！！！！！！！

WenJGo
关注
专栏目录
LeetCode解题心得——反转链表（python）
12-21
在LeetCode中，反转链表是一个常见的数据结构问题，它主要考察了对链表操作的理解以及递归或迭代解决问题的能力。本题的目标是反转给定的单链表，例如，对于输入1->2->3->4->5->NULL，期望得到的输出是5->4->3->2->1...
python【力扣LeetCode算法题库】19-删除链表的倒数第N个节点
01-21
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n 保证是有效的。 进阶： 你能...
Leet Code_力扣原题_leetcode官网_
10-01
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为准备技术面试和提升编程技能而设计。它提供了各种算法和数据结构题目，涵盖了多种编程语言，包括但不限于Java、Python、C++和JavaScript。力扣上的问题...
基于Shell的力扣试题解答设计源码
09-22
本项目是基于Shell开发的力扣试题解答，包含261个文件，其中包括254个Markdown文档文件、3个...该项目旨在为用户提供一个高效、便捷的力扣试题解答工具，支持多种编程语言和文件类型的管理，以提升解答效率和用户体验。
程序员面试金典 – 面试题 02.05. 链表求和
12-22
给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果。 示例： 输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295...
Leetcode 打家劫舍
985小菜鸡
10-08 427
设dp[i]表示前i个房屋能偷取的最大金额。不偷当前房屋 i：那么最大金额是dp[i-1]，即上一个房屋的最大偷取金额。偷当前房屋 i：那么最大金额是，即偷取当前房屋 i，加上不相邻的房屋（即房屋i-2）的最大金额。其中dp[i-1]是不偷当前房屋，是偷当前房屋。
力扣10.13
最新发布
qq_40052678的博客
10-13 242
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
leetcode二叉树（一）-理论基础
weixin_40198632的博客
10-13 616
本节主要参考代码随想录：代码随想录满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。注：第三个不是完全二叉树，不满足最后一个条件： 最下面一层的节点都集中在该层最左
leetcode经典算法题总结
xiaomu_347的博客
10-08 494
针对leetcode算法题常见的五大经典复杂算法进行如下总结
Leetcode 415. Add Strings
小白菜又菜
10-13 90
【代码】Leetcode 415. Add Strings。
C++ | Leetcode C++题解之第472题连接词
Ddddddd_158的博客
10-11 425
C++ | Leetcode C++题解之第472题连接词
LeetCode 面试经典150题 Z字形变换
qq_57349657的博客
10-13 175
Z字形变换
LeetCode组合总和
山雀的博客
10-09 831
LeetCode组合总和
力扣11-盛最多水的容器
qq_40926675的博客
10-09 630
给定一个长度为n的整数数组height。有n条垂线，第i条线的两个端点是(i, 0)和。找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。你不能倾斜容器。
[LeetCode] 面试题01.02 判定是否互为字符重拍
weixin_65043441的博客
10-12 270
判定是否互为字符重排 如果s1和s2互为重排字符，那么s1和s2的长度一定是相等的。然后我们可以借助数组实现一个hash，判断s1的字符及数量是否和s2相同即可。，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。给定两个由小写字母组成的字符串。
Java | Leetcode Java题解之第463题岛屿的周长
m0_57195758的博客
10-08 463
Java | Leetcode Java题解之第463题岛屿的周长
【LeetCode】每日一题 2024_10_10 优质数对的总数 I（暴力/哈希）
Locky136的博客
10-10 484
【LeetCode】每日一题 2024_10_10 优质数对的总数 I（暴力/哈希）
「字符串」Z函数（扩展KMP|exKMP）/ LeetCode 2223（C++）
dakingffo的博客
10-10 990
Z函数是一种独到的匹配算法，虽然国内称之为扩展KMP，其实他更具有Manacher算法的特征。与KMP类似的是，它也是字符串自匹配问题。
力扣SQL仅数据库（1098~1132）
weixin_65642229的博客
10-09 500
编写解决方案，筛选出过去一年中订单总量 少于 10 本 的 书籍，并且 不考虑 上架距今销售 不满一个月 的书籍。假设今天是 2019-06-23。编写解决方案，找出从今天起最多 90 天内，每个日期该日期首次登录的用户数。编写解决方案，找出每位学生获得的最高成绩和它所对应的科目，若科目成绩并列，取。编写解决方案，统计在被报告为垃圾广告的帖子中，被移除的帖子的每日平均占比，编写解决方案，针对每个举报原因统计昨天的举报帖子数量。使用桌面端和手机端的用户人数和总支出金额。的具有该事件的所有公司的。
力扣python160相交链表
12-14
以下是力扣python160相交链表的实现： ```python class Solution: def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode: if not headA or not headB: return None pA, pB = headA, headB while pA != pB: pA = pA.next if pA else headB pB = pB.next if pB else headA return pA ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WenJGo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值