Leetcode-链表
文章目录
- 删除链表的倒数第N个节点（19M）
- 合并两个有序链表（21E）
- 环形链表（141E）
- 环形链表 II（142M）
- 相交链表（160E）
- 链表中倒数第K个结点（剑22E）
- 反转链表（206）
- 回文链表（234E）
删除链表的倒数第N个节点（19M）
19. 删除链表的倒数第 N 个结点
难度：【中等】
在对链表进行操作时，一个常用的技巧就是添加一个哑结点（dummy node）,它的next指向链表的头结点，这样就不需要对头结点进行特殊判断了。
思路一：计算链表长度
先对链表进行一次遍历，得到链表的长度L，随后再从头节点开始对链表进行一次遍历，当遍历到第L-n+1个节点时，就是需要删除的节点。当我们在头结点前面加上dummy节点后，删除的节点就变为了L-n+1的下一个节点，通过修改指针来完成删除操作。
代码如下：
class Solution:def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:def getLength(head: ListNode) -> int:length = 0while head:length += 1head = head.nextreturn lengthdummy = ListNode(0, head)length = getLength(head)cur = dummyfor i in range(1, length - n + 1):cur = cur.nextcur.next = cur.next.nextreturn dummy.next
时间复杂度：O(L)，其中 L 是链表的长度。
空间复杂度：O(1)。
方法二：栈
在对链表进行遍历时将所有的节点依次放入栈，根据栈先进后出的原则，我们弹出的第n个节点就是需要删除的节点，且此时栈顶的节点就是待删除节点的前驱节点。
代码如下：
class Solution:def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:dummy = ListNode(0, head)stack = list()cur = dummywhile cur:stack.append(cur)cur = cur.nextfor i in range(n):stack.pop()prev = stack[-1]prev.next = prev.next.nextreturn dummy.next
时间复杂度：O(L)，其中 L 是链表的长度。
空间复杂度：O(L)，其中 L 是链表的长度。主要为栈的开销。
方法三：双指针
该方法的优点在于不需要预处理链表的长度
使用两个指针 first 和 second 同时对链表进行遍历，并且 first 比 second 超前 n 个节点。当 first 遍历到链表的末尾时second 就恰好处于倒数第 n 个节点。
class Solution:def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:dummy = ListNode(0, head)first = headsecond = dummyfor i in range(n):first = first.nextwhile first:first = first.nextsecond = second.nextsecond.next = second.next.nextreturn dummy.next
时间复杂度：O(L)，其中 LL 是链表的长度。
空间复杂度：O(1)。
合并两个有序链表（21E）
难度：【简单】
方法一：递归
分两种情况：空链表和非空链表
当其中一个为空链表时，可以直接返回另一个链表
当两个链表都为非空链表时，可以使用下面方法进行递归
代码如下：
class Solution:def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:if l1 is None:return l2elif l2 is None:return l1elif l1.val < l2.val:l1.next = self.mergeTwoLists(l1.next,l2)return l1else:l2.next = self.mergeTwoLists(l1,l2.next)return l2
时间复杂度：O(m+n)
空间复杂度：O(m+n)
方法二：迭代
首先要设定一个哨兵节点，可以在最后比较容易地返回合并后的链表。
维护一个 prev 指针，根据 l1和 l2 的大小不断更新 prev 的next 指针。
代码如下：
class Solution:def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:Newhead = ListNode(-1)pre = Newheadwhile l1 and l2:if l1.val < l2.val:pre.next = l1l1 = l1.nextelse:pre.next = l2l2 = l2.nextpre = pre.nextif l1 is None:pre.next = l2else:pre.next = l1return Newhead.next
时间复杂度：O(m+n)
空间复杂度：O(1)
环形链表（141E）
141. 环形链表
难度：【简单】
提供三种解题方法：
最容易想到的就是暴力解法，遍历链表中的节点，由于题目中给出了节点的范围，最多为10的4次方个节点，因此进行遍历，如果遍历过程中遇到空节点（None），说明该链表为无环链表，直接返回False即可，暴力法的时间复杂度为O(n)，空间复杂度为O(1)；
第二种方法是哈希表法，即需要一个set来存储已经遍历过的节点，在遍历节点时判断节点是否被访问过，时间复杂度为O(n)，空间复杂度为O(n)；
方法如下：
方法一：暴力解法
代码如下：
class Solution:def hasCycle(self, head: ListNode) -> bool:count = 10000while head != None and count > 0:head = head.nextcount -= 1if head == None:return Falsereturn True
时间复杂度为O(n)
空间复杂度为O(1)
方法二：哈希表
遍历所有节点，每次遍历一个节点时，判断该节点此前是否被访问过。
如果被访问过，说明该链表是环形链表，并返回True，如果没有，则将该节点加入到哈希表中，遍历完成即可。
代码如下：
class Solution:def hasCycle(self, head: ListNode) -> bool:seen = set()while head:if head in seen:return Trueseen.add(head)head = head.nextreturn False
时间复杂度：O(n)
空间复杂度：O(n)
方法二：快慢指针
定义两个指针，一快一慢，慢指针每一移动一步，快指针每次移动两步，由于快指针比慢指针慢，如果链表有环，则快指针一定会和慢指针相遇。
代码如下：
class Solution:def hasCycle(self, head: ListNode) -> bool:fast = slow = headwhile fast and fast.next:slow = slow.nextfast = fast.next.nextif fast == slow:return Truereturn False
时间复杂度：O(N)
空间复杂度：O(1)
环形链表 II（142M）
142. 环形链表 II
难度：【中等】
解题思路：使用快慢指针
首先，我们要做以下设定，设链表共有 a + b个节点，其中链表头部到链表入口（不计链表入口节点）有 a 个节点，链表环有 b 个节点，同时设快指针走了 f 步，慢指针走了 s 步；
显然，由于快指针是慢指针的两倍，因此有：f = 2s
如果两个指针第一次相遇，则满足：f = s + nb（n表示n个环），也就是 fast 比 slow 多走了 n 个环的长度；
由上可得：当两个指针第一次相遇，有s = nb, f = 2nb
现在需要解决的问题，我们如何知道 a 的大小？
假设现在两指针第一次相遇：
对慢指针来说，如果让慢指针走到链表入口节点，需要 a + nb步，而在相遇时，已经走了 nb 步了，因此，再让慢指针走 a 步就可以走到链表入口节点了；
对快指针来说，如果让快指针从头指针开始走 a 步，快指针也正好走到链表入口节点；
由此可见，两指针发生第二次相遇的时候，刚好都在链表入口处。
代码如下：
class Solution:def detectCycle(self, head: ListNode) -> ListNode:fast = slow = headwhile True:if not (fast and fast.next):returnfast = fast.next.nextslow = slow.nextif fast == slow:breakfast = headwhile fast != slow:fast = fast.nextslow = slow.nextreturn fast
时间复杂度 O(N)
空间复杂度 O(1)
相交链表（160E）
160. 相交链表
难度：【简单】
方法一：暴力解法
对于A中的每一个结点，我们都遍历一次链表B查找是否存在重复结点，第一个查找到的即第一个公共结点。
class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:p = headAwhile p:q = headBwhile q:if p == q:return pq = q.nextp = p.nextreturn p
时间复杂度：O(n^2)
空间复杂度：O(1)
无法通过，会超时。
方法二：
对暴力解法的一个优化方案是：先将其中一个链表存到哈希表中，此时再遍历另外一个链表查找重复结点只需 O(n) 时间。
class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:s = set()p,q = headA,headBwhile p:s.add(p)p = p.nextwhile q:if q in s:return qq = q.nextreturn None
时间复杂度：O(n)
空间复杂度：O(n)
方法三：走过彼此的路
利用两链表长度和相等的性质来使得两个遍历指针同步。
具体做法是：让两指针同时开始遍历，遍历到结尾的时候，跳到对方的头指针，如果有公共结点，则，会同时到达相遇的地方。
代码如下：
class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:p,q = headA,headBwhile p != q:p = p.next if p else headBq = q.next if q else headAreturn p
时间复杂度：O(n)
空间复杂度：O(1)
链表中倒数第K个结点（剑22E）
剑指 Offer 22. 链表中倒数第k个节点
难度：【简单】
两种方法：
方法一：先找到 n，再找到 n - k
先遍历统计链表长度。记为 n；
再设置一个指针走（n - k）步，即可找到链表倒数第 k 个节点。
代码如下;
class Solution:def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:cur = headn = 0while cur:n += 1cur = cur.nextcur = headfor i in range(n - k):cur = cur.nextreturn cur
方法二：使用双指针；
先让一个前指针走 k 步，再让两个指针一起走，当前置镇走到最后尾节点时，后指针正好走到n - k。
代码如下：
class Solution:def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:former = latter = headfor _ in range(k):former = former.nextwhile former:former, latter = former.next,latter.nextreturn latter
时间复杂度：O(n)
空间复杂度：O(1)
反转链表（206）
206. 反转链表
难度：【简单】
参考：https://leetcode-cn.com/problems/reverse-linked-list/solution/shi-pin-tu-jie-206-fan-zhuan-lian-biao-d-zvli/
两种思路：
思路一：迭代
可以使用三个指针来完成迭代，具体可以定义三个指针 pre，cur，nxt，并对 pre 和 cur 进行初始化（令pre为None）
pre = None
cur = head
然后定义一个whlie循环
- 先更新 nxt = cur.next，并将 nxt.next 指向 cur；
- 再调换 pre 和 cur 的位置，直到 cur 为空结束。
代码如下：
class Solution:def reverseList(self, head: ListNode) -> ListNode:pre = Nonecur = headwhile cur:nxt = cur.nextcur.next = prepre = curcur = nxtreturn pre
时间复杂度：O(n)
空间复杂度：O(1)
思路二：递归
明确递推公式的含义：把拿到的链表进行反转，然后返回新的头结点。
首先要写出Newhead，然后修改指针方向，并将 head.next设为None。
需要注意停止条件： head 为 None 或 head.next 为 None
代码如下：
class Solution:def reverseList(self, head: ListNode) -> ListNode:if head == None or head.next == None:return headnewHead = self.reverseList(head.next)head.next.next = headhead.next = Nonereturn newHead
时间复杂度：O(n)
空间复杂度：O(n)
回文链表（234E）
234. 回文链表
难度：【简单】
思路：将值添加到数组中，翻转后进行比较。
将链表值添加到数组列表中，然后直接比较翻转前后是否相等。
class Solution:def isPalindrome(self, head: ListNode) -> bool:vals = []current_node = headwhile current_node is not None:vals.append(current_node.val)current_node = current_node.nextreturn vals == vals[::-1]
时间复杂度：O(n)
空间复杂度：O(n)
Leetcode-链表相关推荐
- LeetCode——链表
LeetCode--链表 目录 概述 找出两个链表的交点 链表反转 归并两个有序的链表 从有序链表中删除重复节点 删除链表的倒数第n个节点 交换链表中的相邻节点 链表求和 回文链表 分隔链表 链表元素 ...
- 面试官系列 - LeetCode链表知识点题型总结
文章目录 前言 知识点 什么是链表 类别 单向链表 循环链表 双向链表 双向循环链表 与数组的性能对比 优缺点 常用技巧 题型总结 基本操作 删除类 翻转类题型 合并链表 环形链表 拆分链表 排序链表 ...
- dummy节点——leetcode链表题必备
做leetcode链表题的时候,需要额外考虑链表头部的特殊情况.但是,往往考虑不够周全,导致最后通过不断试错,修改代码.代码变得臃肿,可读性差. 其实,引入一个dummy节点就可以解决大部分需要考虑头 ...
- 为了OFFER，花了几个小时，刷下Leetcode链表算法题
@Author:Runsen @Date:2020/9/13 链表是我这辈子的痛啊,每次学到链表,就往往不会,就没有继续学下去.现在大四不能继续让这个链表阻碍我了.现在基本是重刷数据结构和算法,毕竟笔 ...
- leetcode(链表专题)
数组模拟链表 #include<iostream> using namespace std;const int N = 100; // 单链表 // head存储链表头,e[]存储节点的值 ...
- LeetCode 链表相关题目总结
之前已经对链表相关常用操作进行了总结.在这里,对 LeetCode 与链表相关的题目解答思路进行总结. 1. 两个链表,求是否有相交的节点并返回 方案一:将两个链表的各节点依次存入两个对象中,然后双层 ...
- leetcode链表题（大致是由易到难
链表系列 leetcode237删除节点 86分隔链表. 剑指 Offer 06. 从尾到头打印链表 解法1:常规 解法2:栈 解法3:用头插法对链表进行逆置 剑指 Offer 24. 反转链表 第一 ...
- 链表OJ无从下手？？磕磕绊绊终于AC却不知其所以然？？？这篇文章带你刷穿Leetcode链表题！
一.前言 学完了链表的基础知识,是时候用一些OJ题目来练练手了!但是我们不仅仅要追求AC,还要能够总结提炼相关的思想方法.在本文中作者将运用虚拟头结点+递归+双指针三种技巧,逐题精讲常见常考的链表OJ ...
- 假设以带头结点的循环链表表示队列_[leetcode链表系列]2 删除链表中的节点
复习链表的插入 链表的一个节点是由数据域和指针域构成,指针域的地址值为下个元素的地址.那么我们需要插入或者删除一个元素怎么处理呢? 先查看原始链表结构,准备将结点x插入链表中. 此时我们需要先保存n节 ...
- 使用循环链表实现一个通讯录的管理程序_【LeetCode链表题型总结】
点击上方蓝字,关注公众号 链表概念的讲解 链表是什么 链表是一种线性数据结构,每个节点都存有数据,通过指针将各个节点链接在一起. 链表的性质 一致性: 每个节点有相同的数据结构,相同的数据大小,内存中 ...
最新文章
- python 第一课
- Linux下运行第一个Java程序成功（Linux下JDK安装和环境变量配置等）
- 《云计算揭秘企业实施云计算的核心问题》——导读
- 帮你理清 SpringBoot 与 SpringMVC 的关系
- 计算机基础- -认识磁盘
- mysql自动dump脚本_MySQL--简单mysqldump脚本
- Android 中的Activity的静态变量问题
- Python 3.7 pygame 下载方法
- 【C++】虚表指针和虚函数表
- 【OpenCV】PNG图片压缩方法
- win10 设备管理器中没端口选项解决方法
- 嵌入式GUI LVGL『Tableview选项卡控件』介绍
- 【R语言爬虫】R语言提交post请求抓取盈盈理财数据
- 里氏代换原则 （Liskov Substitution Principle, LSP）
- java与C/C++的比较
- 蓝桥杯 算法训练 Tennis Rackets （50%通过）
- 彻底弄懂高斯模糊,均值模糊和中值模糊
- python数分之PM2.5案例
- 树莓派救援机器人制作
- 2023中职组网络安全技能竞赛——代码审计解析（超级详细）