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

news2024/11/24 17:17:12

题目链接：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%的人，我们太强了！！！！！！！！！！！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2127621.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【LabVIEW学习篇 - 23】：简单状态机

【LabVIEW学习篇 - 23】：简单状态机

文章目录 简单状态机状态机的创建和了解状态机实现红绿灯 简单状态机 一个优秀的应用程序离不开好的程序框架&#xff0c;不仅要很好满足用户的功能需求&#xff0c;还要考虑到系统的稳定性、实时性、可扩展性、可维护性&#xff0c;执行效率等方面。借用一些成熟的设计框架&a…
阅读更多...
Jmeter终极线程组“Ultimate Thread Group“如何使用？

Jmeter终极线程组“Ultimate Thread Group“如何使用？

1、安装,点击"选项"&#xff0c;再点击"Plugins Manager"&#xff0c;下载"Custom Thread Groups" 2、添加"jpgc - Ultimate Thread Group" 3、"jpgc - Ultimate Thread Group"使用
阅读更多...
HarmonyOS开发5.0【骨架屏】 app界面制作

HarmonyOS开发5.0【骨架屏】 app界面制作

实现原理 1.定义组件和状态变量&#xff1a; 使用 Entry 和 Component 装饰器定义了一个名为 IvSkeleton 的组件。 定义了一个状态变量 translageX&#xff0c;初始值为 -100%&#xff0c;用于控制闪电效果的位置。 定义了两个数值变量 widthValue 和 heightValue&#xff0c;…
阅读更多...
wangeditor——cdn引入的形式创建一个简易版编辑器——js技能提升

wangeditor——cdn引入的形式创建一个简易版编辑器——js技能提升

昨天同事那边有个需求&#xff0c;就是要实现聊天功能&#xff0c;需要用到一个富文本编辑器&#xff0c;参考如下&#xff1a; 上面的这个效果图是博客园的评论输入框 最终使用wangEditor编辑器实现的效果如下&#xff1a; 只保留了个别的菜单&#xff1a; 默认模式的wangE…
阅读更多...
/bin/bash的作用

/bin/bash的作用

1、为啥使用不了很多命令&#xff1f; 我刚进入一个新系统&#xff1a; 我当时蒙蔽了&#xff0c;这是啥意思&#xff0c;为啥没命令? 原因是&#xff1a;当时进入的shell并没有初始化这些路径环境&#xff0c;所以正确的方法是&#xff1a; 2、/bin/bash运行的过程中执行…
阅读更多...
Android12_13左上角状态栏数字时间显示右移动

Android12_13左上角状态栏数字时间显示右移动

文章目录 问题场景解决问题 一、基础资料二、代码追踪三、解决方案布局的角度解决更改paddingStart 的默认值设置marginLeft 值 硬编码的角度解决 问题场景 1&#xff09;早期一般屏幕都是方形的&#xff0c;但是曲面屏&#xff0c;比如&#xff1a;好多车机Android产品、魔镜…
阅读更多...
9月11号作业

9月11号作业

头文件 #include <cmath> #include <QApplication> #include <QMainWindow> #include <QLabel> #include <QTimer> #include <QVBoxLayout> #include <QRandomGenerator> #include <QTimerEvent> #include <QTextT…
阅读更多...
如何在 Ubuntu 系统上部署 Laravel 项目 ？

如何在 Ubuntu 系统上部署 Laravel 项目 ？

到目前为止&#xff0c;Laravel 是 PHP 开发人员构建 api 和 web 应用程序的首选。如果你是新手的话&#xff0c;将 Laravel 应用程序部署到线上服务器上可能有点棘手。 在本指南中&#xff0c;我们将向您展示在 Ubuntu 系统中部署 Laravel 应用程序的全过程。 Step 1: Updat…
阅读更多...
SprinBoot+Vue教务管理系统的设计与实现

SprinBoot+Vue教务管理系统的设计与实现

目录 1 项目介绍2 项目截图3 核心代码3.1 Controller3.2 Service3.3 Dao3.4 application.yml3.5 SpringbootApplication3.5 Vue 4 数据库表设计5 文档参考6 计算机毕设选题推荐7 源码获取 1 项目介绍 博主个人介绍&#xff1a;CSDN认证博客专家&#xff0c;CSDN平台Java领域优质…
阅读更多...
【深度学习】搞懂卷积神经网络(一)

【深度学习】搞懂卷积神经网络(一)

卷积神经网络是一种具有局部连接&#xff0c;权重共享等特性的深层前馈神经网络。一般是由卷积层&#xff0c;池化层&#xff0c;全连接层交叉堆叠而成&#xff0c;使用反向传播算法进行训练。卷积神经网络具有一定程度上的平移&#xff0c;缩放和旋转不变性&#xff0c;较前馈…
阅读更多...
【目标检测数据集】工具扳手数据集1000张VOC+YOLO格式

【目标检测数据集】工具扳手数据集1000张VOC+YOLO格式

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;1003 标注数量(xml文件个数)&#xff1a;1003 标注数量(txt文件个数)&#xff1a;1003 标注…
阅读更多...
Mac M芯片上安装统信UOS 1070arm64虚拟机

Mac M芯片上安装统信UOS 1070arm64虚拟机

原文链接&#xff1a;Mac M芯片上安装统信UOS 1070 arm64虚拟机 Hello&#xff0c;大家好啊&#xff01;今天给大家带来一篇关于如何在苹果M系列芯片的Mac电脑上&#xff0c;通过VMware安装ARM64版统信UOS 1070桌面操作系统的文章。随着苹果M1和M2芯片的推出&#xff0c;越来越…
阅读更多...
MATLAB中swapbytes函数用法

MATLAB中swapbytes函数用法

目录 语法 说明 示例 交换标量的字节顺序 交换向量的字节顺序 交换三维数组的字节顺序 swapbytes函数的功能交换字节顺序。 语法 Y swapbytes(X) 说明 Y swapbytes(X) 将数组 X 中每个元素的字节排序从 little endian 转换为 big endian&#xff08;或相反&#xff…
阅读更多...
解决：Vue3 - defineProps 设置默认值报错问题

解决：Vue3 - defineProps 设置默认值报错问题

目录 1&#xff0c;问题2&#xff0c;分析2.1&#xff0c;按报错提示信息测试2.2&#xff0c;测试 vue-i18n 3&#xff0c;解决 1&#xff0c;问题 使用 defineProps 指定默认值时报错&#xff0c;代码如下&#xff1a; <template><input type"text" :pla…
阅读更多...
1分钟从出差申请到自动入账，用友BIP超级版超级快！

1分钟从出差申请到自动入账，用友BIP超级版超级快！

在当今的商业战场&#xff0c;时间就是金钱&#xff0c;效率决定成败。对于频繁出差的商务精英而言&#xff0c;繁琐的差旅申请与报销流程无疑是巨大的时间浪费。现在&#xff0c;用友BIP超级版商旅费控一体化解决方案&#xff0c;将彻底改变这一现状&#xff0c;操作仅需1分钟…
阅读更多...
【无人机设计与控制】固定翼四旋翼无人机UAV俯仰姿态飞行模糊自整定PID控制Simulink建模

【无人机设计与控制】固定翼四旋翼无人机UAV俯仰姿态飞行模糊自整定PID控制Simulink建模

摘要 本研究设计了一种基于模糊自整定PID控制的固定翼四旋翼无人机俯仰姿态控制系统。利用Simulink建立了无人机俯仰控制系统模型&#xff0c;通过模糊控制器自适应调节PID参数&#xff0c;实现了对无人机俯仰角度的精确控制。实验结果表明&#xff0c;该控制策略在不同飞行状…
阅读更多...
机器学习-特征工层

机器学习-特征工层

机器学习-特征工层 仅个人笔记使用&#xff0c;感谢点赞关注 目前仅专注于 NLP 大模型 机器学习和前后端的技术学习和分享 感谢大家的关注与支持&#xff01;
阅读更多...
【 html+css 绚丽Loading 】000047 玄武流转盘

【 html+css 绚丽Loading 】000047 玄武流转盘

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享htmlcss 绚丽Loading&#xff01;并提供具体代码帮助大家深入理解&#xff0c;彻底掌握&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495…
阅读更多...
有关 Element-ui 的一些思考

有关 Element-ui 的一些思考

本篇文章是基于 element-ui 的 主题样式修改 曾经为了修改组件风格，一个项目用了上百个样式穿透，后来才发现定制一个主题就够了！ 第一步，在官网的主题页面，修改背景色、字体颜色及边框颜色 第二步，下载主题 第三步，用下载的css文件替换掉默认的css文件
阅读更多...
得物超级品质保障中心，助力电商品质保障迈向新高度

得物超级品质保障中心，助力电商品质保障迈向新高度

近期记者走进国内知名潮流电商平台——得物App的超级品质保障中心。该中心位于上海市嘉定区&#xff0c;总建筑面积达到约12万平方米&#xff0c;是集查验鉴别、鉴别研究、质量管理、仓储流转等功能于一体的综合性服务设施&#xff0c;全面覆盖了服装、配饰、奢侈品等多个业务品…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023