leetCode-hot100-链表专题

leetCode-hot100-链表专题

  • 链表简介
  • 单链表
    • 单链表的使用
    • 例题
      • 206.反转链表
      • 19.删除链表的倒数第N个结点
      • 24.两两交换链表中的节点
      • 25.K个一组翻转链表
  • 双向链表
    • 双向链表的使用
  • 循环链表
      • 61.旋转链表
      • 141.环形链表
      • 142.环形链表Ⅱ
  • LinkedList
    • LinkedList的使用

链表简介

参考博客:java数据结构之链表。
链表是一种常见的基础数据结构,它由一系列节点组成,每个节点包含数据域和一个或多个指针域,用于指向其它节点。链表不像数组那样在内存中连续存储,它的节点可以分散地存储在内存中,通过指针连接起来。
链表的主要优点是它对插入和删除操作的效率很高,尤其是当链表的长度变化很大时。在链表中进行插入和删除操作,只需要改变相应节点的指针,而不需要像数组那样进行大量元素的移动。而需要频繁查找元素的场景适合使用顺序表。

链表的主要类型包括:

  • 单向链表:每个节点只包含一个指向下一个节点的指针。
  • 双向链表:每个节点包含两个指针,一个指向前一个节点,一个指向下一个节点。
  • 循环链表:链表中最后一个节点的指针指向第一个节点,形成一个环。
  • 双向循环链表:是双向链表和循环链表的结合,每个节点有两个指针,分别指向前一个节点和后一个节点,并且最后一个节点的指针指向第一个节点。

需要理解的点
关于连续?
链表在逻辑上是连续的,但是物理上并不一定是连续的,链表的结点一般都是从堆上申请,由于每次都是按照一定的分配策略,所以两次申请到的结点可能连续,可能不连续。
关于“头”
链表中的头节点的data域中是空的,一般编码设置头节点都是为了方便后续的操作,不需要进行特殊处理,而且可以简化链表的操作,关于头节点,看到的博文中有个很形象的比喻:带不带头可以简单理解为有人驾驶的列车和无人驾驶的列车,有人驾驶的列车不能在火车头前面加车厢,第一节车厢永远是驾驶室;而无人驾驶的列车则可以在最前面加车厢,哪节车厢在最前面哪节就是头。即head只是用来标识。java数据结构之链表。(这篇博文讲解了链表操作的底层逻辑,文章的内容也是以此为参考,很不戳!建议大家都去读读)
关于“循环”
判断是不是循环就看最后一个结点的next域存放的是null还是第一个结点的地址。

单链表

单链表的使用

方法备注
addFirst(int data)将data插入链表头部
addLast(int data)将data插入链表尾部
addIndex(int index,int data)在下标为index位置插入data,第一个数据节点为0号下标
contains(int key)查找关键字key是否在单链表当中
remove(int key)删除第一次出现关键字为key的节点
removeAllKey(int key)删除所有值为key的节点
size()得到单链表的长度
clear()清空链表
display()从头结点开始遍历,若该结点不等于null就打印输出该结点的元素

例题

206.反转链表

思路:
本题是25.K个一组翻转链表,25题中需要对分段的链表进行翻转,而本题翻转整个链表,直接翻转即可,步骤如下:

  • 初始化两个指针,precurpre开始时为null,因为它需要指向当前节点cur之前的一个节点,而反转开始前没有这样的节点。cur初始化为链表的头部head
  • 进入一个循环,只要cur不是null,就执行循环体。这意味着只要当前节点不是链表的最后一个节点,就继续反转。
  • 在循环内部,首先使用一个临时节点next保存cur的下一个节点。这是必要的,因为一旦cur.next被修改指向pre,我们就失去了对原始下一个节点的引用。
  • 接下来,将cur.next指向pre,这是反转节点的关键步骤。
  • 然后,将pre移动到它的新位置,即当前的cur节点。
  • 最后,将cur移动到下一个节点,即之前保存在next中的节点。

cur变为null时,循环结束,此时pre是新的头节点,因为它指向原始链表的最后一个节点。
时间复杂度:
这个算法的时间复杂度是O(n),其中n是链表的长度。这是因为算法会遍历整个链表一次,每个节点都会被访问一次以进行反转。
代码实现:

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

19.删除链表的倒数第N个结点

思路1
本题采用快慢指针来解决,让快指针比慢指针先走n步,当快指针到达链表尾部时,慢指针所指向的下一个结点就是需要删除的倒数第n个结点,在做链表相关的题目时一般需要在头节点的前面设置一个虚拟的结点,方便边界的判断。详细的视频讲解点击视频讲解-删除链表的倒数第N个结点。
在这里插入图片描述

时间复杂度
时间复杂度为O(n),其中n是链表的长度。代码中有一个循环,循环的次数是链表的长度n,因此时间复杂度为O(n)
代码实现

class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummy = new ListNode(0);ListNode slow = dummy;ListNode fast = dummy;dummy.next = head;//让快指针先向前走n步for(int i = 0;i < n;i++){fast=fast.next;}while(fast.next != null){slow = slow.next;fast = fast.next;}//删除慢指针的下一个结点,即需要删除的结点slow.next = slow.next.next;return dummy.next;}
}

思路2:
删除链表的第n个节点比较简单,所以我们可以先将链表翻转,然后删除第n个节点后再次翻转即可,其中翻转节点的操作在25.K个一组翻转链表以及206.反转链表中都有用到,具体的步骤解释详细见206题的解析。
时间复杂度:
时间复杂度为O(n),其中n为链表长度。
代码实现:

class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummy = new ListNode(0);//翻转链表,删除第n个节点dummy.next = reserve(head);ListNode cur = dummy;//循环找到要删除节点的前一个节点for(int i = 0; i < n - 1; i++){cur = cur.next;}//删除第n个节点cur.next = cur.next.next;//翻转链表,得到删除倒数第n个节点的链表dummy.next = reserve(dummy.next);return dummy.next;}//翻转链表private ListNode reserve(ListNode head){ListNode pre = null;ListNode cur = head;while(cur != null){ListNode next = cur.next;cur.next = pre;pre = cur;cur = next;}return pre;}
}

24.两两交换链表中的节点

思路
本题采用三指针来解决,首先需要新建一个虚拟头节点,方便操作,然后分别新建三个指针指向虚拟头节点和头节点以及头节点的下一个节点,通过操作三个指针使得节点互换位置,然后将指针整体后移,相同的操作。详细的讲解点击视频讲解-两两交换链表中的节点。
在这里插入图片描述

时间复杂度
时间复杂度为O(n),其中n是链表的长度。
代码实现

class Solution {public ListNode swapPairs(ListNode head) {ListNode dummy = new ListNode(0);dummy.next = head;//定义两个指针分别指向虚拟头节点dummy和其下一个节点ListNode pre = dummy;ListNode cur = dummy.next;while(cur != null && cur.next != null){//定义第三个指针ListNode next = cur.next;pre.next = next;cur.next = next.next;next.next = cur;pre = cur;cur = cur.next;}return dummy.next;}
}

25.K个一组翻转链表

思路
本题采用的思路是,先将链表按K个节点一组分割,然后单独对每一组进行翻转,最后再拼接起来即可,翻转函数逻辑比较简单,就是采用三个指针,每次让中间的指针(刚开始指向头节点)指向其前一个指针并整体后移,重复操作。分割和拼接的操作其实也很简单,如果看代码不太明白,可以画个链表跟着操作走一遍,就会明白每一步的含义,代码里有注释,希望对你有用,详细的视频讲解点击视频讲解-K个一组翻转链表。
时间复杂度
时间复杂度为O(n),其中n是链表的长度。代码中有一个while循环,每次循环都会处理k个节点(反转、拼接),所以循环的次数最多为n/k。在循环中,反转操作的时间复杂度为O(k),拼接操作的时间复杂度为O(1)。因此,总的时间复杂度可以近似为O(n)
代码实现

class Solution {public ListNode reverseKGroup(ListNode head, int k) {ListNode dummy = new ListNode(0);dummy.next = head;//定义首尾指针指向dummyListNode start = dummy;ListNode end = dummy;//按K个一组分割链表while(true){for(int i = 0 ;i < k && end != null;i++) end = end.next;if(end == null) break;//分割后的链表的头节点ListNode startNext = start.next;//分割后的剩余链表的头节点ListNode endNext = end.next;//分割前K个节点end.next = null;//对前K个节点的链表进行翻转start.next = reverse(start.next);//将翻转后的链表的与剩余的节点拼接到一起startNext.next = endNext;//更新头尾节点,开始下一轮的翻转start = end = startNext;}return dummy.next;}//定义反转函数private ListNode reverse(ListNode head){ListNode cur = head;ListNode pre = null;while(cur != null){ListNode next = cur.next;//每次cur指针指向前一个节点,达到翻转的目的,然后将三个指针后移,重复操作,直到cur为空cur.next = pre;pre = cur;cur = next;}return pre;} 
}

双向链表

双向链表相当于是单链表中的一种改进,在单链表的基础上增加了一个前驱结点来存放前一个结点的位置,这使得某些操作会更加简单。

双向链表的使用

双向链表的使用和单链表基本相同。

方法备注
addFirst(int data)将data插入链表头部
addLast(int data)将data插入链表尾部
addIndex(int index,int data)在下标为index位置插入data,第一个数据节点为0号下标
contains(int key)查找关键字key是否在单链表当中
remove(int key)删除第一次出现关键字为key的节点
removeAllKey(int key)删除所有值为key的节点
size()得到单链表的长度
clear()清空链表
display()从头结点开始遍历,若该结点不等于null就打印输出该结点的元素

循环链表

1.循环链表的表尾节点指针next指向头结点
2.循环链表从一个节点出发可以找到其他任意一个节点
3.循环链表的判空操作和普通单链表的判空方法基本相同,不同之处在于循环链表的判空是判断头结点的指针是否指向头结点,而普通单链表的判空是判断头结点的指针是否指向null
4.判断节点n是否为循环单链表的表尾节点和普通单链表的判断方法基本相同,不同之处在于循环链表的判空是判断n节点的指针是否指向头结点,而普通单链表的判空是判断n节点的指针是否指向null。

61.旋转链表

思路:
(1)成环:

  • 首先检查链表是否为空,如果为空,则直接返回null
  • 定义一个指针cur,初始指向头节点head
  • 遍历链表,计算链表的长度n,并将链表的最后一个节点指向头节点,使链表形成一个环。

(2)找到需要分段的节点:

  • 再次遍历链表,这次是为了找到新的头节点位置。由于旋转次数k可能大于链表长度n,因此使用k % n来获取实际需要旋转的次数。
  • 循环n - k % n次,找到旋转后链表的头节点的前一个节点,即cur

(3)改变头节点的位置,断开环:

  • cur.next设置为新的头节点head
  • cur.next设置为null,断开环,使链表恢复为线性结构。

(4)返回头节点:
最后返回新的头节点head,此时链表已经完成了旋转操作。视频讲解点击视频讲解-旋转链表。
在这里插入图片描述

时间复杂度:
时间复杂度为O(n),其中n为链表的长度。
代码实现:

class Solution {public ListNode rotateRight(ListNode head, int k) {if(head == null) return null;//1.成环ListNode cur = new ListNode();cur = head;int n = 1;while(cur.next != null){cur = cur.next;n++;}cur.next = head;//2.找到需要分段的节点for(int i = 0;i < n - k % n;i++){cur = cur.next;}//3.改变头节点的位置,断开环head = cur.next;cur.next = null;return head;}
}

141.环形链表

思路:
本题主要是下面两个思想:
快慢指针: 通过使用两个速度不同的指针在链表中遍历,可以有效地检测环的存在。慢指针每次走一步,快指针每次走两步。
相遇点: 如果链表中有环,快指针会在环中追上慢指针,最终导致两者相遇。如果没有环,快指针会在到达链表末尾时终止。
为什么快指针不能每次移动三步或者更多呢?快指针每次移动两步,慢指针每次移动一步。这种配置保证了快指针的速度是慢指针的两倍。这样,在最坏的情况下,当链表中存在环时,快指针和慢指针将在环中相遇,在这种情况下,相遇所需的步数最多是环长度的两倍。
如果快指针每次移动三步或更多步,相遇的模式变得更复杂,需要更多的步骤来分析和证明算法的正确性。同时,更快的速度可能会跳过慢指针,特别是在环比较小的情况下,增加了算法的复杂性。视频讲解点击视频讲解-环形链表。
时间复杂度
时间复杂度为O(n),其中n为链表长度。
代码实现:

public class Solution {public boolean hasCycle(ListNode head) {ListNode fast = head;ListNode slow = head;while(fast != null && fast.next != null){slow = slow.next;fast = fast.next.next;if(slow == fast){return true;}}return false;}
}

142.环形链表Ⅱ

思路:
算法思想:
(1)初始化:

  • 使用两个指针 fastslow,它们都从链表的头节点 head 开始。

(2)检测环的存在:

  • 在一个 while 循环中,fast 指针每次移动两步,slow 指针每次移动一步。
  • 如果链表中存在环,fastslow 指针最终会在环内相遇(相同的节点)。

(3)寻找环的起点:

  • 一旦 fastslow 指针相遇,将 slow 指针重新指向链表的头节点,同时保持 fast 指针在相遇点。
  • 这时,slowfast 指针每次都移动一步。当它们再次相遇时,相遇点就是环的起始节点。

证明:
在这里插入图片描述
由上面的证明可知,当slowfast第一次相遇时,此时让slow回到headfast从第一次相遇的点同步出发,最终二者会在环的入点相遇(fast回到headslow在第一次相遇点出发是同样的效果)。

视频讲解点击视频讲解-环形链表Ⅱ。
时间复杂度:
时间复杂度为O(m+n),其中m为链表非环部分的长度,n为环的长度,无论链表的非环部分和环的长度如何,算法的运行时间都与环的长度成线性关系,所以时间复杂度可以简化为 O(n)
代码实现:

public class Solution {public ListNode detectCycle(ListNode head) {ListNode fast = head;ListNode slow = head;while(fast != null && fast.next != null){slow = slow.next;fast = fast.next.next;//第一次相遇,将slow置为头节点if(slow == fast){slow = head;while(slow != fast){slow = slow.next;fast = fast.next;}return slow;}}return null;}
}

LinkedList

LinkedList底层使用了双向链表并实现了List接口,不支持随机访问,但是在任意位置插入和删除元素的效率很高,适合需要频繁插入和删除元素的场景。

LinkedList的使用

//创建一个空的LinkedList
List<Integer> list = new LinkedList<>()

常用方法:

方法备注
add(e)在尾部插入e
add(int index, e)将e插入index位置
addAll(C)将C中的元素全部插入尾部
remove(int index)删除 index 位置元素
remove(Object o)删除遇到的第一个 o
get(int index)获取下标 index 位置元素
set(int index, e)将下标 index 位置元素设置为 e
clear()清空
contains(Object o)判断 o 是否在线性表中
indexOf(Object o)返回第一个 o 所在下标
lastIndexOf(Object o)返回最后一个 o 的下标
subList(int fromIndex, int toIndex)截取部分 list

三种遍历方法

//使用forEach遍历
for(int item : list){System.out.print(e + " ");
}
//使用迭代器遍历-正向
ListIterator<Integer> i1 = list.listIterator();
while(i1.hasNext()){System.out.print(i1.next+" ");
}
//使用迭代器遍历-反向
ListIterator<Integer> i2 = list.listIterator(list.size());
while (i2.hasPrevious()) {System.out.print(i2.previous()+" ");
}

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

掉电安全文件系统分析

掉电安全FS 掉电安全的文件系统&#xff08;Power-Fail Safe File Systems&#xff09;被设计为在电源故障或系统崩溃的情况下仍能保持数据一致性的文件系统。这样的文件系统通常通过使用日志&#xff08;journaling&#xff09;或写时复制&#xff08;copy-on-write&#xff…

文章解读与仿真程序复现思路——电力系统自动化EI\CSCD\北大核心《协同考虑空气质量与热舒适度的空调系统双层优化控制策略》

本专栏栏目提供文章与程序复现思路&#xff0c;具体已有的论文与论文源程序可翻阅本博主免费的专栏栏目《论文与完整程序》 论文与完整源程序_电网论文源程序的博客-CSDN博客https://blog.csdn.net/liang674027206/category_12531414.html 电网论文源程序-CSDN博客电网论文源…

升级 Kubernetes Ingress NGINX Controller: 自助编译 NGINX 的实践

保持软件的更新对于系统的安全性和稳定性至关重要。本文将介绍如何从源代码自助编译 NGINX&#xff0c;并将其集成到 Kubernetes Ingress NGINX Controller 镜像中&#xff0c;以实现 NGINX 的升级。此方法不仅可以提高系统的安全性&#xff0c;还可以定制 NGINX 的功能&#x…

ipvsadm命令总结

ipvsadm命令总结 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01; 什么是ipvsadm命令&#xff1f; ipvsadm是Linux系统下的一个命令行工具&#xff0c;用于配置…

【Oracle】调用HTTP接口

Oracle调用http接口 前情提要1.创建HTTP请求函数2.创建ACL并授予权限3.测试HTTP请求函数一点建议 前情提要 公司唯有oracle被允许访问内外网&#xff0c;因此在oracle中发起HTTP请求。 1.创建HTTP请求函数 CREATE OR REPLACE FUNCTION HTTP_REQUEST(v_url VARCHAR2,--請求地…

数据资产安全保卫战:构建多层次、全方位的数据安全防护体系,守护企业核心数据资产安全

一、引言 在信息化时代&#xff0c;数据资产已成为企业运营的核心&#xff0c;其安全性直接关系到企业的生存与发展。然而&#xff0c;随着网络技术的飞速发展&#xff0c;数据泄露、黑客攻击等安全威胁日益增多&#xff0c;给企业的数据资产安全带来了严峻挑战。因此&#xf…

CSS动画实现让元素一直旋转

在CSS中&#xff0c;使用keyframes动画和transform: rotate()属性来创建一个无限循环的旋转动画。以下是一个简单的示例&#xff0c;展示了如何使一个元素&#xff08;比如一个div&#xff09;无限地旋转&#xff1a; keyframes spin { from { transform: rotate(0deg); } …

202483读书笔记|《把你写进诗歌里》——人生是一场不知何时散场的约会,爱慕向来短暂,失去才是唯一出路

202483读书笔记|《把你写进诗歌里》——人生是一场不知何时散场的约会&#xff0c;爱慕向来短暂&#xff0c;失去才是唯一出路 摘录 《把你写进诗歌里&#xff08;2020年度中国优秀诗歌&#xff09;》&#xff0c;作者上官文露。并不惊艳&#xff0c;中英文双语对照的一本诗集&…

深入理解和应用Eureka:服务注册与发现的利器

目录 一 Eureka简介 什么是Eureka? 为什么选择Eureka? 二 Eureka的基本概念 Eureka Server Eureka Client 服务注册与发现 三 Eureka的工作原理 注册服务 心跳机制 服务发现 缓存机制 四 Eureka的配置与部署 配置Eureka Server 配置Eureka Client 五 Eureka的…

Python | Leetcode Python题解之第168题Excel表列名称

题目&#xff1a; 题解&#xff1a; class Solution:def convertToTitle(self, columnNumber: int) -> str:ans list()while columnNumber > 0:columnNumber - 1ans.append(chr(columnNumber % 26 ord("A")))columnNumber // 26return "".join(an…

RC4混淆变形

RC4混淆变形 一、RC4混淆变形1. 修改初始密钥调度算法 (KSA)2. 修改伪随机生成算法 (PRGA)3. 引入非线性变换4. 使用多个状态数组5. 增加密钥混淆步骤6.示例代码 二、RC4算法详解2.1. 密钥调度算法 (KSA)2.2. 伪随机生成算法 (PRGA)2.3. 加密/解密2.4 RC4 C实现2.5 代码解析 RC…

新手装修 避坑课2.0:装修之前一定要做好功课(55节课)

课程下载&#xff1a;https://download.csdn.net/download/m0_66047725/89388333 更多资源下载&#xff1a;关注我。 课程目录 第01节1.装修前准备工作.mp4 第02节开篇.mp4 第03节2.装修需要提前定好的设备和材料.mp4 第04节3.自装还是找装修公司.mp4 第05节4.自装怎么找…

Elementui的el-dropdown组件使用与案例

一、使用 trigger 属性用于设置下拉菜单的触发方式&#xff0c;可以是 click&#xff08;点击触发&#xff09;或 hover&#xff08;悬停触发&#xff09;。command 属性用于在 el-dropdown-item 上设置命令值。当用户点击某个菜单项时&#xff0c;会触发 command 事件&#x…

HTTP的持久连接(Persistent Connection)

目录 HTTP的持久连接&#xff08;Persistent Connection&#xff09;持久连接的工作原理HTTP/1.0 与 HTTP/1.1 的区别示例持久连接的优点持久连接的缺点超时机制 HTTP的持久连接&#xff08;Persistent Connection&#xff09; HTTP 的持久连接&#xff08;Persistent Connect…

win11照片裁剪视频无法保存问题解决

win11照片默认走核显&#xff0c;intel的显卡可能无法解码&#xff0c;在设置里把照片的显示卡默认换成显卡就好了

红队内网攻防渗透:内网渗透之Linux内网权限提升技术:LXDDockerRbash限制型bash

红队内网攻防渗透 1. 内网权限提升技术1.1 Linux系统提权-普通用户-LXD容器1.2 Linux系统提权-普通用户-Docker容器1.3 权限在docker里面1.4 Linux系统提权-普通用户-Rbash限制型bash1. 内网权限提升技术 利用参考 https://gtfobins.github.io/LXD、LXC 和 Docker 是三种不同…

企业UDP文件传输工具测速的方式(下)

在前一篇文章中&#xff0c;我们深入讨论了UDP传输的基本概念和镭速UDP文件传输工具如何使用命令行快速进行速度测试。现在&#xff0c;让我们进一步探索更为高级和灵活的方法&#xff0c;即通过整合镭速UDP的动态或静态库来实现网络速度的测量&#xff0c;以及如何利用这一过程…

每日一练 - OSPF邻接与邻居关系

01 真题题目 下面关于 OSPF 邻居关系和邻接关系描述,正确的是&#xff1a; A.OSPF 路由器在交换信息之曲必须建立邻接关系 B.并非所有的邻居关系都可以成为邻接关系 C.接芙系由 OSPF 的 HELLO 协议维护 D.邻居关系是从邻接关系选出的为了交换路由信息而形成的关系 02 真题…

动态分区存储管理实验要点和难点以及常见报错解决

动态分区存储管理实验的主要目的是熟悉并掌握动态分区分配的各种算法,以及动态分区中分区回收的各种情况,并能够实现分区合并。以下是实验的一些主要内容和步骤: 实验准备:了解动态分区存储管理的基本原理和策略,包括动态分区的特点、虚拟内存管理的目标、页式虚拟存储管理…

差分数组汇总

本文涉及知识点 算法与数据结构汇总 差分数组 令 a[i] ∑ j : 0 i v D i f f [ i ] \sum_{j:0}^{i}vDiff[i] ∑j:0i​vDiff[i] 如果 vDiff[i1]&#xff0c;则a[i1…]全部 如果vDiff[i2]–,则a[i2…]全部–。 令11 < i2 &#xff0c;则&#xff1a; { a [ i ] 不变&…