链表 OJ（一）

news2025/2/23 6:38:24

移除链表元素

题目连接：
https://leetcode.cn/problems/remove-linked-list-elements/description/

在这里插入图片描述

使用双指针法，开始时，一个指针指向头节点，另一个指针指向头节点的下一个结点，然后开始遍历链表删除结点。

这里要注意如果是空链表的话，使用双指针第二个指针会发生空指针异常，所以要判断一下

最后程序运行到最后，我们还差头节点没有判断，最后加上即可。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null) {
            return head;
        }

        ListNode prev = head;
        ListNode cur = head.next;
        while(cur != null) {
            if(cur.val == val) {
                prev.next = cur.next;
            } else {
                prev = cur;
            }
            cur = cur.next;
        }

        if(head.val == val) {
            head = head.next;
        }
        return head;
    }
}

反转链表

题目连接：
https://leetcode.cn/problems/reverse-linked-list/description/

在这里插入图片描述

我们还是使用双指针，不过这次有一个指针就是头指针，因为反转链表之后的头指针会发生改变，那还不如直接让头指针一起移动，先将另一个指针指向头指针的下一个结点，然后开始遍历链表，把每一个结点的指针指向的对象变为前面的对象。

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null) {
            return head;
        }
        
        ListNode cur = head.next;
        head.next = null;

        while(cur != null) {
            ListNode tmp = cur.next;
            cur.next = head;
            head = cur;
            cur = tmp;
        }
        
        return head;
    }
}

链表的中间结点

题目链接：
https://leetcode.cn/problems/middle-of-the-linked-list/description/

在这里插入图片描述

使用快慢指针，快指针每次走两步，慢指针每次走一步，最后慢指针所指向的结点就是 中间结点

原理：fast = 2slow = 总路程

这里要注意循环的结束条件：
在这里插入图片描述当fast== null 并且 fast.next == null时，才能进入循环，并且 fast==null,要放在前面，因为只用fast不是null时才能进行 fast.next 的判断

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;

        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        return slow;
    }
}

返回倒数第 k 个节点

题目链接：
https://leetcode.cn/problems/kth-node-from-end-of-list-lcci/description/

在这里插入图片描述

还是使用快慢指针，先让快指针走 k-1 步，然后慢指针和快指针一起走，每次走一步，最后快指针走到最后一个结点时，慢指针所指向的节点就是倒数第 k 个节点。

原理就是让slow和fast的差值j就是k

class Solution {
    public int kthToLast(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;

        for(int i=0; i<k-1; i++) {
            fast = fast.next;
        }

        while(fast.next != null) {
            slow = slow.next;
            fast = fast.next;
        }

        return slow.val;
    }
}

合并两个有序的链表

题目链接：
https://leetcode.cn/problems/merge-two-sorted-lists/description/
在这里插入图片描述

创建一个新的头节点，list1和list2开始遍历各自的链表，然后比较，插入到新链表中，最后再看一下哪些链表没有遍历完，然后把没有遍历完的链表直接插入即可。

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null) {
            return list2;
        }
        if(list2 == null) {
            return list1;
        }

        ListNode newHead = new ListNode();
        ListNode cur = newHead;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                cur.next = list1;
                list1 = list1.next;
            } else {
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        
        if(list1 != null) {
            cur.next = list1;
        }
        if(list2 != null) {
            cur.next = list2;
        }

        return newHead.next;
    }
}

分割链表

题目链接：
https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

在这里插入图片描述

我们可以将单链表拆成两个链表，一个链表存储小于x 的结点，另一个链表存储大于等于x 的结点，然后将两个链表合并

这里建议使用带头链表，也就是我们常说的带哨兵位的链表，这个链表最大的好处就是可以避免头插的复杂情况，既然使用了哨兵位，就要知道最后哨兵位是要被丢弃的。

public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        ListNode headA = new ListNode(-1);
        ListNode aLast = headA;
        ListNode headB =  new ListNode(-1);
        ListNode bLast = headB;

        ListNode cur = pHead;
        while(cur != null) {
            if(cur.val < x) {
                aLast.next = cur;
                aLast = aLast.next;
            } else {
                bLast.next = cur;
                bLast = bLast.next;
            }
            cur = cur.next;
        }

        aLast.next = headB.next;
        bLast.next = null;
        return headA.next;
    }
}

链表的回文结构

题目链接：
https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId=49&&tqId=29370&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking
在这里插入图片描述

解题思路：
我们可以使用快慢指针来遍历链表找到中间结点，然后就可以把后半部分的链表进行反转，之后从这个链表头尾结点开始向中间遍历。

易错点：
1.链表的结点个数有奇数和偶数两种类型，我们需要分别讨论
2.区分奇数个结点还是偶数个结点可以从一开始找完中间结点的时候，从fast入手,因为找中间结点的循环结束就是fast最后指向尾节点还是null。
3.要一定要保存好fast的信息，因为后面在反转链表的时候fast其实已经发生了改变。

public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        //如果是空链表返回true
        if(A == null) {
            return true;
        }

        ListNode slow = A;
        ListNode fast = A;

        //找到中间结点
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        //保存fast的结点信息，避免后面反转链表丢失信息
        boolean isOdd = true;//是否是奇数个结点
        if(fast == null) {
            isOdd = false;
        }

        //反转后半部分的链表
        ListNode prev = slow;
        ListNode cur = slow.next;
        while(cur != null) {
            ListNode curN = cur.next;
            cur.next = prev;
            prev = cur;
            cur = curN;
        }

        //前后遍历链表
        ListNode pA = A;
        ListNode last = prev;

        //偶数个结点
        if(!isOdd) {
            while(pA.next != last) {
                if(pA.val != last.val) {
                    return false;
                }
                pA = pA.next;
                last = last.next;
            }
            if(pA.val != last.val) {
                return false;
            }
        }
        if (isOdd) { //奇数个结点
            while(pA != last) {
                if(pA.val != last.val) {
                    return false;
                }
                pA = pA.next;
                last = last.next;
            }
        }

        return true;
    }
}

相交链表

题目链接：
https://leetcode.cn/problems/intersection-of-two-linked-lists/

在这里插入图片描述

由于是相交链表，在公共结点之前两个链表可能有一个差值，如果我们能找到这个差值，让长的链表先走差值不属，然后两个链表一起遍历，直到相遇到公共结点。

这个差值就是两个链表的长度的差。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0;
        int lenB = 0;

        ListNode cur = headA;
        while(cur != null) {
            lenA++;
            cur = cur.next;
        }
        
        cur = headB;
        while(cur != null) {
            lenB++;
            cur = cur.next;
        }

        int k = 0;
        ListNode pl = null;
        ListNode ps = null;
        if(lenA > lenB) {
            k = lenA - lenB;
            pl = headA;
            ps = headB;
        } else {
            k = lenB - lenA;
            pl = headB;
            ps = headA;
        }

        while(k != 0) {
            pl = pl.next;
            k--;
        }

        while(pl != ps) {
            pl = pl.next;
            ps = ps.next;
        }

        return pl;
    }
}

环形链表

题目链接：
https://leetcode.cn/problems/linked-list-cycle/

在这里插入图片描述

这里使用快慢指针，快指针一次走两步，慢指针一次走一步，当快指针运动到fast == null 或者 fast .next == null 这个条件时，说明链表不存在环，如果有链表存在环，那么快指针就会先进入到环中一直做圆周运动，一定会存在某一个时刻快慢指针会相遇，这时候返回true即可。

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;

        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                return true;
            }
        } 

        return false;
    }
}

为什么快指针每次走两步，慢指针走一步可以？

快指针会率先进入环中，然后慢指针后晚一点进入环中，由于两个指针的速度是每次差一步，也就是说两个指针每运动一次，二者之间的距离就会缩短1步，最后两个指针一定会相遇。

快指针一次走3步，走4步，…n步行吗？
快指针如果每次走三步，假设两个指针的位置如下：
在这里插入图片描述
那二者永远都不会相遇

其他情况由读者自行探讨~~

环形链表Ⅱ （找入口点）

题目链接：
https://leetcode.cn/problems/linked-list-cycle-ii/description/

在这里插入图片描述

我们还是使用快慢指针来做。

假设起点与入口点的距离为 x ，环的周长为 C ，慢指针与快指针相遇点离起点的距离为L ：
在这里插入图片描述
慢指针所走的路程为 x + L
快指针所走的路程为 x + L + nC (n为正整数，n = 1,2,3,4…)

这里解释一下两者的路程计算问题：
在慢指针还没有进入口点的时候，就已经至少路过一次相遇点，所以当慢指针刚刚进入环中的时候，快指针最少已经走了一圈，最多走了 n 圈。
因为慢指针刚进入环中的时候，快指针和它最多相差一个圈的距离，并且快指针的速度比慢指针的速度要快，所以慢指针是不可能走完一圈的（假设慢指针走完一圈，那快指针一定走完一圈再多一点，所以慢指针在完成一圈之前一定会被追上），所以慢指针所走的路程为 x + L，快指针所走的路程为 x + L + nC (n为正整数，n = 1,2,3,4…)中的 nC 是遇到慢指针之前就已经完成好的

当快慢指针在环中相遇时，由于快指针的速度是慢指针的速度的两倍，所以慢指针的路程是快指针的一半，即 2 * (x + L) = x + L + nC，化简整理得 x + L = nC 即 x = nC - L

推导结论：
让一个指针从头开始遍历，另一个指针从相遇点开始遍历，两个指针每次走一步，一定会在入口点相遇。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast) {
                break;
            }
        }

        //没有环
        if(fast == null || fast.next == null) {
            return null;
        }

        ListNode meet = fast;
        ListNode str = head;

        while(meet != str) {
            meet = meet.next;
            str = str.next;
        }
        
        return str;
    }
}

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

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

相关文章

【React Hooks原理 - useState】

【React Hooks原理 - useState】

概述 useState赋予了Function Component状态管理的能力&#xff0c;可以让你在不编写 class 的情况下使用 state 。其本质上就是一类特殊的函数&#xff0c;它们约定以 use 开头。本文从源码出发&#xff0c;一步一步看看useState是如何实现以及工作的。 基础使用 function …
阅读更多...
高盛开源的量化金融 Python 库

高盛开源的量化金融 Python 库

GS Quant GS Quant是用于量化金融的Python工具包&#xff0c;建立在世界上最强大的风险转移平台之一之上。旨在加速量化交易策略和风险管理解决方案的开发&#xff0c;凭借25年的全球市场经验精心打造。 它由高盛的定量开发人员&#xff08;定量&#xff09;创建和维护&#…
阅读更多...
Java内存划分详解：从基础到进阶

Java内存划分详解：从基础到进阶

Java内存划分详解&#xff1a;从基础到进阶 1. 程序计数器&#xff08;Program Counter Register&#xff09;2. Java虚拟机栈&#xff08;Java Virtual Machine Stack&#xff09;3. 堆&#xff08;Heap&#xff09;4. 方法区&#xff08;Method Area&#xff09;5. 运行时常量…
阅读更多...
网络编程的学习之udp

网络编程的学习之udp

Udp编程过程 Sento不会阻塞 实现聊天室效果 上线 聊天 下线 服务端需要一个地址&#xff0c;去保留名字和ip地址 交互的时候发结构体 下面这个宏只能在c语言里使用 ser.sin_port htons(50000); 上面是端口号50000以上&#xff0c;两边要一样 这里是不要让udp发的太快&am…
阅读更多...
YOLOv10改进 | Conv篇 | CVPR2024最新DynamicConv替换下采样（解决低FLOPs陷阱）

YOLOv10改进 | Conv篇 | CVPR2024最新DynamicConv替换下采样（解决低FLOPs陷阱）

一、本文介绍 本文给大家带来的改进机制是CVPR2024的最新改进机制DynamicConv其是CVPR2024的最新改进机制&#xff0c;这个论文中介绍了一个名为ParameterNet的新型设计原则&#xff0c;它旨在在大规模视觉预训练模型中增加参数数量&#xff0c;同时尽量不增加浮点运算&#x…
阅读更多...
imx6ull/linux应用编程学习（17）利用mqtt上传开发板数据，和控制开发板led（基于正点）

imx6ull/linux应用编程学习（17）利用mqtt上传开发板数据，和控制开发板led（基于正点）

1.关于如何创建自己的服务器&#xff0c;可看上篇文章 imx6ull/linux应用编程学习&#xff08;16&#xff09;emqx &#xff0c;mqtt创建连接mqtt.fx-CSDN博客 2.实现任务&#xff1a;&#xff08;正点原子教程源码改&#xff09; (1)用户可通过手机或电脑远程控制开发板上的…
阅读更多...
微软Win11 24H2七月更新补丁KB5040435发布！附下载

微软Win11 24H2七月更新补丁KB5040435发布！附下载

系统之家于7月10日发出最新报道&#xff0c;微软为Win11用户发布了24H2版本七月的最新更新补丁KB5040435。用户升级系统后&#xff0c;会发现版本号升至 26100.1150。此次更新针对远程身份验证拨入用户服务(RADIUS)协议与 MD5冲突等问题进行修复。接下来跟随小编看看此次更新的…
阅读更多...
利用 AI 解放双手：把“贾维斯”带进现实 | 开源专题 No.64

利用 AI 解放双手：把“贾维斯”带进现实 | 开源专题 No.64

Significant-Gravitas/AutoGPT Stars: 160k License: MIT AutoGPT 是开源 AI 代理生态系统的核心工具包。 提供构建、测试和委托 AI 代理的工具。AutoGPT 处于 AI 创新前沿&#xff0c;提供文档、贡献指南以及快速开始创建自己的代理。包含强大的组件如 Forge 和 Benchmark&…
阅读更多...
Ollama完整教程：本地LLM管理、WebUI对话、Python/Java客户端API应用

Ollama完整教程：本地LLM管理、WebUI对话、Python/Java客户端API应用

老牛同学在前面有关大模型应用的文章中&#xff0c;多次使用了Ollama来管理和部署本地大模型&#xff08;包括&#xff1a;Qwen2、Llama3、Phi3、Gemma2等&#xff09;&#xff0c;但对Ollama这个非常方便管理本地大模型的软件的介绍却很少。 目前&#xff0c;清华和智谱 AI 联…
阅读更多...
视图库对接系列(GA-T 1400)十四、视图库对接系列(本级)新增、修改订阅

视图库对接系列(GA-T 1400)十四、视图库对接系列(本级)新增、修改订阅

说明 之前我们已经对接的设备，设备的话比较简单，是设备主动推送数据到平台的。 相信大家已经会了，那今天开始的话，我们来做对接平台，相对难点点。 但搞懂了核心的订阅流程的话，其实就不难了。 对接平台 订阅接口 订阅接口的话，有几个，添加、查询、更新、删除、取消…
阅读更多...
【MOT】《Multiple Object Tracking in Recent Times: A Literature Review》

【MOT】《Multiple Object Tracking in Recent Times: A Literature Review》

原文 Bashar M, Islam S, Hussain K K, et al. Multiple object tracking in recent times: A literature review[J]. arXiv preprint arXiv:2209.04796, 2022.https://arxiv.org/pdf/2209.04796 参考文章 多目标跟踪最新综述&#xff08;基于Transformer/图模型/检测和关联…
阅读更多...
RK3568平台（vendor篇）vendor storage分区

RK3568平台（vendor篇）vendor storage分区

一.简介 rockchip vendor storage是一种用于存储SN, MAC, LAN, BT等数据的区域&#xff0c;它具有不会丢失和系统启动各个阶段都可以访问的特性。它使用GPT分区表格式&#xff0c;并在U-boot, kernel和用户空间中提供了相应的驱动文件和接口。 rockchip vendor storage是一种特…
阅读更多...
硅纪元AI应用推荐 | 百度橙篇成新宠，能写万字长文

硅纪元AI应用推荐 | 百度橙篇成新宠，能写万字长文

“硅纪元AI应用推荐”栏目&#xff0c;为您精选最新、最实用的人工智能应用&#xff0c;无论您是AI发烧友还是新手&#xff0c;都能在这里找到提升生活和工作的利器。与我们一起探索AI的无限可能&#xff0c;开启智慧新时代&#xff01; 百度橙篇&#xff0c;作为百度公司在202…
阅读更多...
软航文档控件VUE示例运行及控件替换方法记录

软航文档控件VUE示例运行及控件替换方法记录

目录 示例运行 步骤一、npm install 步骤二、npm run dev 软航文档控件替换 附 vue小白记录一下软航文档控件VUE示例的运行方法以及示例中控件的替换过程。 示例运行 在已经安装好VUE环境的电脑上&#xff0c;VUE环境部署可以参考另一篇&#xff1a;配置VUE环境过程中 …
阅读更多...
3.相机标定原理及代码实现（opencv）

3.相机标定原理及代码实现（opencv）

1.相机标定原理 相机参数的确定过程就叫做相机标定。 1.1 四大坐标系及关系 &#xff08;1&#xff09;像素坐标系&#xff08;单位&#xff1a;像素&#xff08;pixel&#xff09;&#xff09; 像素坐标系是指相机拍到的图片的坐标系&#xff0c;以图片的左上角为坐标原点&a…
阅读更多...
nvm安装使用 nrm使用

nvm安装使用 nrm使用

因维护老项目及开发新项目同时进行&#xff0c;需要使用不同版本的node进行运行&#xff0c;所以用nvm进行多个版本的node维护&#xff0c;通过nrm进行镜像源管理切换 简介 Node.js 是一种基于 Chrome V8 引擎的 JavaScript 运行环境&#xff0c;用于构建高性能的网络应用程序…
阅读更多...
mobx学习笔记

mobx学习笔记

mobx介绍 mobx是一个功能强大&#xff0c;上手容易的状态管理工具。MobX背后的哲学很简单:任何源自应用状态的东西都应该自动地获得。利用getter和setter来收集组件的数据依赖关系&#xff0c;从而在数据发生变化的时候精确知道哪些组件需要重绘。 mobx和redux的区别 mobx更…
阅读更多...
javaweb学习day1《HTML篇》--新浪微博（前端页面的创建思路及其HTML、css代码详解）

javaweb学习day1《HTML篇》--新浪微博（前端页面的创建思路及其HTML、css代码详解）

一、前言 本篇章为javaweb的开端&#xff0c;也是第一篇综合案例&#xff0c;小编也是看着黑马程序员的视频对里面的知识点进行理解&#xff0c;然后自己找一个新浪微博网页看着做的&#xff0c;主要还是因为懒&#xff0c;不想去领黑马程序员的资料了。 小编任务javaweb和ja…
阅读更多...
人工智能算法工程师(中级)课程6-sklearn机器学习之聚类问题与代码详解

人工智能算法工程师(中级)课程6-sklearn机器学习之聚类问题与代码详解

大家好&#xff0c;我是微学AI&#xff0c;今天给大家介绍一下人工智能算法工程师(中级)课程6-sklearn机器学习之聚类问题与代码详解。在机器学习领域&#xff0c;聚类是一种无监督学习方法&#xff0c;旨在将相似的数据点划分为同一类别。sklearn是一个广泛应用于机器学习的Py…
阅读更多...
初识C++语言（1）

初识C++语言（1）

目录 C语言简介 C 语言概述 C 语言的特点 语言简洁紧凑&#xff0c;使用灵活方便 运算符丰富 数据结构丰富 结构化语言 生成的代码质量高 可移植性强 C程序结构 C语言系统的使用 一.启动Dev-C 二、新建源程序 三…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023