--- theme: github highlight: vs --- > 分门别类刷算法，坚持，进步！ > > 刷题路线参考：https://github.com/youngyangyang04/leetcode-master > > **https://github.com/chefyuan/algorithm-base** ![LeetCode通关：链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f769408a8d2b4a75838cc40426d70a00~tplv-k3u1fbpfcp-zoom-1.image) # 链表基础 > 在开始刷题之前，我们最好先了解一下链表的一些基础知识，那么现在，我们开始吧。链表是一种链式存储的线性表，不要求逻辑上相邻的数据元素在物理位置上也相邻。 ## 单链表一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的引用。也可以称之为数据域和指针域。入口节点称为头结点，最后一个节点指向null。如图所示： ![单链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/439453a1be414d3a8fcaf36b0b9dcbf0~tplv-k3u1fbpfcp-zoom-1.image) ## 双链表双链表，顾名思义，是有两个方向的链表。每个节点除了有指向下一个节点的引用，还有指向上一个节点的引用。双链表除了可以从前往后遍历，还可以从后往前遍历。 ![双向链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0ea247af142f458593ec990e35a8b794~tplv-k3u1fbpfcp-zoom-1.image) ## 循环链表循环链表，就是最后一个节点的后继指向头结点，头节点的前驱指向最后一个节点。 ![循环链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/56a3fc600c4b44029a694fdc12922928~tplv-k3u1fbpfcp-zoom-1.image) ## 链表的存储方式我们知道链表在内存中不是连续分配的。链表是通过指针域的指针链接内存中的各个节点。所以链表在内存中是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。 ![链表内存分配](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/72b7d4c512ec4098951551f5f525b20d~tplv-k3u1fbpfcp-zoom-1.image) ## 链表的定义链表的定义主要包含两个部分：**数据域**和**指针域**。在Java中因为屏蔽了指针的存在，我们的定义可以是数据，后继/前驱节点。 - 单链表： ````java public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ```` - 双链表： ````java public class ListNode { int val; ListNode prev; ListNode next; ListNode(int x) { val = x; } } ```` ## 链表基本操作我们以单链表为例，来看一下链表的一些基本操作： - 删除节点 ![链表删除节点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d696053896c4435f81b438a10506aa91~tplv-k3u1fbpfcp-zoom-1.image) - 插入节点 ![插入节点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/14c433e971bd4249ae6d5b64ca39a70d~tplv-k3u1fbpfcp-zoom-1.image) 图中的插入和删除的时间复杂度都为``O(1)``。但是需要注意，这里的情况是插入和删除已经知道前趋节点的情况。如果，还需要检索相应的节点，那么时间复杂度是``O(n)``。 # 链表操作 ## [LeetCode203. 移除链表元素](https://leetcode-cn.com/problems/remove-linked-list-elements/) ☕ 题目：203. 移除链表元素 (https://leetcode-cn.com/problems/remove-linked-list-elements/) ❓ 难度：简单 📕 描述：给你一个链表的头节点 `head` 和一个整数 `val` ，请你删除链表中所有满足 `Node.val == val` 的节点，并返回 **新的头节点** 。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/db06aa9de1624d24a7a511eb5a54c4cf~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：删除链表节点，需要分为两种情况： - 删除节点是头结点：我们将头结点指向头结点的下一个节点 ![头结点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c5baff5a85814878a017b189486dc309~tplv-k3u1fbpfcp-zoom-1.image) - 删除节点是非头结点：我们需要将当前节点的前一个节点指向当前节点的下一个节点 ![非头结点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/efc23715688e492bb49abefcf9beafa4~tplv-k3u1fbpfcp-zoom-1.image) 我们来看一下代码实现： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 203. 移除链表元素 * @author 三分恶 * @date 2021/7/25 10:08 */ public ListNode removeElements(ListNode head, int val) { if (head == null) { return null; } ListNode cur = head; ListNode prev = head; while (cur != null) { ListNode temp = cur.next; //删除节点 if (cur.val == val) { //头节点 if (cur == head) { head = temp; } //非头节点 if (cur != head) { prev.next = cur.next; } } else { prev = cur; } cur = temp; } return head; } ```` ⏰ 时间复杂度：O(n)。 🏠 空间复杂度：O(1)。 > 这道题，还有一个更巧妙一点的做法，就是**虚拟头指针**——虚拟头指针是链表算法题中非常好用的一个技巧。 💡 思路：可以设置一个虚拟的头指针，让它的next指向头节点，这样头节点的删除就和普通节点是一致的了。 ![虚拟头指针](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/aa02ddf09d214ad2bf4b598e9e8c8ab4~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 203. 移除链表元素 * @author 三分恶 * @date 2021/7/25 10:08 */ public ListNode removeElements(ListNode head, int val) { if (head == null) { return null; } //虚拟头节点 ListNode dummy = new ListNode(-1, head); ListNode prev = dummy; ListNode cur = head; while (cur != null) { if (cur.val == val) { prev.next = cur.next; } else { prev = cur; } cur = cur.next; } return dummy.next; } ```` 🚗 时间复杂度：O(n)。 🏠 空间复杂度：O(1)。 ## [LeetCode707. 设计链表](https://leetcode-cn.com/problems/design-linked-list/) ☕ 题目：707. 设计链表 (https://leetcode-cn.com/problems/design-linked-list/) ❓ 难度：中等 📕 描述：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。在链表类中实现这些功能： - get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 - addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点 - addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。 - addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。 - deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。 **示例：** ```` MyLinkedList linkedList = new MyLinkedList(); linkedList.addAtHead(1); linkedList.addAtTail(3); linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3 linkedList.get(1); //返回2 linkedList.deleteAtIndex(1); //现在链表是1-> 3 linkedList.get(1); //返回3 ```` 提示： - 所有val值都在 [1, 1000] 之内。 - 操作次数将在 [1, 1000] 之内。 - 请不要使用内置的 LinkedList 库。 💡 思路：这是一道大题。链表基本操作的图示在前面已经给出了。比较简练的方式是设置一个伪头节点，保证链表永不为空，这样操作起来会方便很多。但是，我本人看过一点Java链表的代码，所以不想采用这种方式。 PS：这里踩了一个坑，没仔细审题，链表index是从0开始的，导致思考5分钟，AC两小时。好了，我们直接看代码： ````java /** * @Author: 三分恶 * @Date: 2021/7/25 * @Description: 707. 设计链表 * https://leetcode-cn.com/problems/design-linked-list/ *

* 链表界节点是 0——index **/ public class MyLinkedList { //链表元素的个数 int size; //头结点 ListNode head; /** * 初始化链表 */ public MyLinkedList() { size = 0; } /** * 获取第index个节点的数值 */ public int get(int index) { //非法参数 if (index < 0 || index >= size) { return -1; } ListNode cur = head; for (int i = 0; i < index; i++) { cur = cur.next; } return cur.val; } /** * 在链表最前面插入一个节点 */ public void addAtHead(int val) { addAtIndex(0, val); } /** * 在链表的最后插入一个节点 */ public void addAtTail(int val) { addAtIndex(size, val); } /** * 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。 * 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点 * 如果 index 大于链表的长度，则返回空 */ public void addAtIndex(int index, int val) { //非法参数 if (index > size) { return; } if (index < 0) { index = 0; } //如果链表为空，直接作为头节点 if (size == 0) { head = new ListNode(val); size++; return; } //插入 size++; ListNode addNode = new ListNode(val); //插入头节点之前 if (index == 0) { addNode.next = head; head = addNode; return; } //找到前驱节点 ListNode pre = head; for (int i = 0; i < index - 1; i++) { pre = pre.next; } addNode.next = pre.next; pre.next = addNode; } /** * 删除第index个节点 */ public void deleteAtIndex(int index) { if (index < 0 || index > size-1) { return; } size--; //头节点 if (index == 0) { head = head.next; return; } //非头节点 ListNode prev = head; for (int i = 0; i < index - 1; i++) { prev = prev.next; } //删除节点 prev.next = prev.next.next; } } ```` ⏰时间复杂度： - addAtHead： O(1) - addAtInder，get，deleteAtIndex: O(n)。 - addAtTail：O(n)。 🏠空间复杂度：所有的操作都是 O(1)。 > 虚拟头指针，以及双链表的实现，这里就留个白了。 # 双指针解决的题目 ## [剑指 Offer 22. 链表中倒数第k个节点](https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/) ☕ 题目：剑指 Offer 22. 链表中倒数第k个节点 (https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/) ❓ 难度：简单 📕 描述：输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c9cafc7e393949168611ca590269bbfb~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：这道题可以用双指针的办法。以示例说明，一个指针``pre``在前，先跑1步，一个指针``after``在后，跟着跑，pre到头的时候，刚好afer是倒数第二个。 ![倒数第k个节点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0377235b91c145efa2b64fa3cfcf454f~tplv-k3u1fbpfcp-zoom-1.image) 代码实现： ````java /** * 剑指 Offer 22. 链表中倒数第k个节点 * * @param head * @param k * @return */ public ListNode getKthFromEnd(ListNode head, int k) { if (head == null) { return null; } ListNode preNode = head, afterNode = head; int step = 0; while (preNode!=null) { preNode = preNode.next; step++; if (step > k) { afterNode = afterNode.next; } } return afterNode; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode876. 链表的中间结点](https://leetcode-cn.com/problems/middle-of-the-linked-list/) ☕ 题目：876. 链表的中间结点 (https://leetcode-cn.com/problems/middle-of-the-linked-list/) ❓ 难度：简单 📕 描述：给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 ![示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9439624bf336400195a4aa1b150a7a0f~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：和上一道题有点类似。上一道题是两个指针分先、后。这道题可以两个指针分``快``、``慢``。一示例1为例，``fast``指针跑两步，``slow``指针跑一步，``fast``指针恰好跑的是``slow``的两倍，``fast``指针跑到头了，``slow``指针不就恰好跑到中间了嘛！ ![链表的中间节点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/64a84dcc370a4a4ab60fa8955e0cd956~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * 876. 链表的中间结点 * * @param head * @return */ public ListNode middleNode(ListNode head) { if (head == null) { return null; } //定义快慢指针 ListNode fastNode = head, slowNode = head; while (fastNode != null && fastNode.next != null) { //快指针走两步 fastNode = fastNode.next.next; //慢指针走一步 slowNode = slowNode.next; } return slowNode; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode19. 删除链表的倒数第 N 个结点](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/) ☕ 题目：19. 删除链表的倒数第 N 个结点 (https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/) ❓ 难度：中等 📕 描述：给你一个链表，删除链表的倒数第 `n` 个结点，并且返回链表的头结点。 **进阶：**你能尝试使用一趟扫描实现吗？ ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/945c2b9ef8934390abe17e5d5e34b93d~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：这道题上手是不是就觉得很熟？这是 ``203.移除链表元素`` 和 ``剑指 Offer 22. 链表中倒数第k个节点 ``的结合。那么解法，我们同样可以结合这两道题。 - 快慢指针找到倒数第N个节点 - 虚拟头指针辅助删除 ![删除倒数第N个节点](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/707e7986a52a4016983165588ddbf791~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 19. 删除链表的倒数第 N 个结点 * @author 三分恶 * @date 2021/7/25 17:17 */ public ListNode removeNthFromEnd(ListNode head, int n) { if (head == null) { return null; } //快慢指针 ListNode fast = head, slow = head; //虚拟头节点 ListNode dummy = new ListNode(-1); dummy.next = head; //一个指针从虚拟头节点开始跑 ListNode preSlow = dummy; //计算步数 int step = 0; while (fast != null) { //fast先走n步 fast = fast.next; step++; //slow开始移动 if (step > n) { slow = slow.next; preSlow = preSlow.next; } } //找到倒数第n个节点，和它的前驱 preSlow.next = slow.next; return dummy.next; } ```` ⏰ 时间复杂度：O(n)。 ## [剑指 Offer 52. 两个链表的第一个公共节点](https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/) ☕ 题目：876. 链表的中间结点 (https://leetcode-cn.com/problems/middle-of-the-linked-list/) ❓ 难度：简单 📕 描述：给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/28eea677076840e08b9408a36c184393~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：他们都说这道题浪漫，我却不想听什么狗屁的浪漫爱情故事，我只想搞钱。这道题可以用双指针解决，定义两个指针，当某一指针遍历完链表之后，然后掉头去另一个链表的头部，继续遍历。因为速度相同所以他们第二次遍历的时候肯定会相遇。如图（来自参考[3]）： ![图片来自参考[3]](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/da59fff65050430c80d16661c736a3fb~tplv-k3u1fbpfcp-zoom-1.image) 代码实现： ````java /** * 剑指 Offer 52. 两个链表的第一个公共节点 * * @param headA * @param headB * @return */ public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if (headA == null || headB == null) { return null; } //定义两个节点 ListNode nodeA = headA, nodeB = headB; while (nodeA != nodeB) { //没到头就后移，到头，就指向另一树头结点 if (nodeA != null) { nodeA = nodeA.next; } else { nodeA = headB; } //另一个节点也一样 if (nodeB != null) { nodeB = nodeB.next; } else { nodeB = headA; } } return nodeA; } ```` ⏰ 时间复杂度：O(m+n)，m和n分别为两个链表的长度。 [160. 相交链表](https://leetcode-cn.com/problems/intersection-of-two-linked-lists/) 、[面试题 02.07. 链表相交](https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/) 和这道题基本是一模一样的。 ## [LeetCode206. 反转链表](https://leetcode-cn.com/problems/reverse-linked-list/) ☕ 题目：206. 反转链表 (https://leetcode-cn.com/problems/reverse-linked-list/) ❓ 难度：简单 📕 描述：给你单链表的头节点 `head` ，请你反转链表，并返回反转后的链表。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/37f48020cc844980aef7d8a5813ff592~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：这是一道非常经典的题目。翻转怎么做呢？遍历链表，将当前节点的后继指向当前。 ![反转链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f86be442434347ea805b4737f1168e39~tplv-k3u1fbpfcp-zoom-1.image) 在这里我们要额外引入两个指针： - 一个``prev``表示前趋，用于反转时候后继的指向。 - 一个``temp``用于临时存储下一个节点，这个temp是用来干什么的？用来遍历，因为反转之后，原来的next节点已经指向prev了。说真的，作为一个C语言菜鸡，我又想起了被``指针数组``、``数组指针``支配的日子，所以我画了一个作为Java程序员理解的示意图，如有不当之处，请指出。 ![反转链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b06bfacf4f3b4a38b8200b489360e244~tplv-k3u1fbpfcp-zoom-1.image) 也找到了一张动图（参考[1])： ![在这里插入图片描述](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f53f1a156e33476ea4d2b78b7ef8a013~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * 206. 反转链表 * * @param head * @return */ public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode current = head; while (current != null) { //保存下一个节点 ListNode temp = current.next; //修改当前节点后继指向 current.next = prev; //修改前趋节点 prev = current; current = temp; } return prev; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode92. 反转链表 II](https://leetcode-cn.com/problems/reverse-linked-list-ii/) ☕ 题目：92. 反转链表 II (https://leetcode-cn.com/problems/reverse-linked-list-ii/) ❓ 难度：中等 📕 描述：给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e5b695b4a9824ff9a3552b4444814138~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：反转链表经常容易忘，我们再做一道进阶的题目来巩固一下。这道题什么思路呢？我们可以把反转的这一部分拆出来，作为新的链表，反转新链表，然后再和前后的节点重新连接。 ![反转链表-II](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/79cc152fce444b148eec83a4267887db~tplv-k3u1fbpfcp-zoom-1.image) 代码实现： ````java /** * @return ListNode * @Description: 92. 反转链表 II * @author 三分恶 * @date 2021/7/24 0:32 */ public ListNode reverseBetween(ListNode head, int left, int right) { //虚拟头节点 ListNode dummy = new ListNode(-1); dummy.next = head; ListNode cur = dummy; //一、获取被截取的子链表的前、后节点 //移动到左节点前一个节点 int i = 0; for (; i < left - 1; i++) { cur = cur.next; } //保存左节点的前一个节点 ListNode leftPre = cur; //移动到right节点 for (; i < right; i++) { cur = cur.next; } //保存右节点的后一个节点 ListNode rightAfter = cur.next; //二、截取子链表 //切断右节点后的部分 cur.next = null; //左节点作为子链表头节点 ListNode sonHead = leftPre.next; //切断左节点前的部分 leftPre.next = null; //三、反转子链表 ListNode rNode = reverseList(sonHead); //四：重新连接 leftPre.next = rNode; sonHead.next = rightAfter; return dummy.next; } /** * @return ListNode * @Description: 反转链表 * @author 三分恶 * @date 2021/7/25 10:06 */ ListNode reverseList(ListNode head) { ListNode prev = null; ListNode cur = head; while (cur != null) { ListNode temp = cur.next; cur.next = prev; prev = cur; cur = temp; } return prev; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode234. 回文链表](https://leetcode-cn.com/problems/palindrome-linked-list/) ☕ 题目：234. 回文链表(https://leetcode-cn.com/problems/palindrome-linked-list/) ❓ 难度：简单 📕 描述：请判断一个链表是否为回文链表。 ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/21338cf461a247289039a68ab9b6152b~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：要是双向链表就好了，直接一个指针从头到尾，一个指针从尾到头，但是这是一个单链表。所以我们可以用一个列表先把之给存起来，再用双指针分别从两头遍历比较。代码如下： ````java /** * 234. 回文链表 * 将值复制到集合 * * @param head * @return */ public boolean isPalindrome(ListNode head) { if (head == null) { return false; } List nodes = new ArrayList<>(16); //将链表的值放入集合 while (head != null) { nodes.add(head.val); head = head.next; } //双向遍历集合 int start = 0, end = nodes.size() - 1; while (start < end) { if (!nodes.get(start).equals(nodes.get(end))) { return false; } start++; end--; } return true; } ```` ⏰ 时间复杂度：O(n)，其中 n 指的是链表的元素个数，。 🏠 空间复杂度：O(n)，其中 n 指的是链表的元素个数，因为我们用了一个ArrayList来存储数据。但是题目里还提出了一个进阶： > 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？既然空间复杂度O(1)，那么就不能引入新的存储结构。还是上面那句话，要是双向链表就好了，我们就双向比较。所以，考虑一下，我们可以把链表的后半段翻转一下，然后再比较。 ![回文链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c33ffa97b13a45399c19c8f054ae528b~tplv-k3u1fbpfcp-zoom-1.image) 为了完成这个目的，大概需要分三步： - 找到中间结点 - 翻转链表后半段 - 前半段和后半段比较所以这种做法就是 ``876. 链表的中间结点`` 和 ``206. 反转链表`` 的组合。代码实现如下： ````java /** * 234. 回文链表 * 快慢指针法 * * @param head * @return */ public boolean isPalindrome(ListNode head) { //找到中间节点 ListNode midNode = findMid(head); //翻转链表 ListNode tailHead = reverseList(midNode); //比较 while (tailHead != null) { if (head.val != tailHead.val) { return false; } head = head.next; tailHead = tailHead.next; } return true; } /** * 找到中间节点 * * @param head * @return */ ListNode findMid(ListNode head) { ListNode fast = head, slow = head; while (fast != null && fast.next != null) { fast = fast.next.next; slow = slow.next; } return slow; } /** * 翻转链表 * * @param head * @return */ ListNode reverseList(ListNode head) { ListNode current = head; ListNode prev = null; while (current != null) { //保存下一个节点 ListNode temp = current.next; //修改当前节点后继指向 current.next = prev; //修改前趋节点 prev = current; current = temp; } return prev; } ```` ⏰ 时间复杂度：O(n)。 🏠 空间复杂度：O(1)。 ## [LeetCode141. 环形链表](https://leetcode-cn.com/problems/linked-list-cycle/) ☕ 题目：141. 环形链表 (https://leetcode-cn.com/problems/linked-list-cycle/) ❓ 难度：简单 📕 描述：给定一个链表，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。如果链表中存在环，则返回 true 。否则，返回 false 。 ![示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6811c21a0bfe4912ac40aae2200c97f7~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：这道题是经典的快慢指针，一个指针跑的块，一个指针跑的慢，如果链表成环的话，慢指针一定会追上快指针。 ![幻形链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a48e8d9890aa43e580f9ca4946eb8680~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * @return boolean * @Description: 141. 环形链表 * @author 三分恶 * @date 2021/7/25 20:16 */ public boolean hasCycle(ListNode head) { if (head == null) { return false; } //定义快慢指针 ListNode fast = head, slow = head; //遍历链表 while (fast != null && fast.next != null) { //快指针移动两步 fast = fast.next.next; //慢指针移动一步 slow = slow.next; //快、慢指针相遇 if (fast == slow) { return true; } } return false; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode142. 环形链表 II](https://leetcode-cn.com/problems/linked-list-cycle-ii/) ☕ 题目：142. 环形链表 II (https://leetcode-cn.com/problems/linked-list-cycle-ii/) ❓ 难度：中等 📕 描述：给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。说明：不允许修改给定的链表。进阶： - 你是否可以使用 O(1) 空间解决此题？ ![题目示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0253d9d34c0345ef9553a7e882b58172~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：这道题，乍一看，是 ``141. 环形链表`` 的进阶，仔细一看，没那么简单。 ``141. 环形链表``快指针只管追慢指针，不管在哪追上就行，但这个不行，我们要返回追上的节点。怎么办？我们可以用一个集合把链表节点存进去，要是成环的话，放入的节点肯定会有重复的。这个集合用什么呢？用HashSet比较合适。 ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 142. 环形链表 II * @author 三分恶 * @date 2021/7/25 20:40 */ public ListNode detectCycle(ListNode head) { if (head == null) { return null; } HashSet set = new HashSet<>(16); while (head != null) { //判断set中是否包含当前元素 if (set.contains(head)) { return head; } //添加元素 set.add(head); //继续迭代 head = head.next; } return null; } ```` ⏰ 时间复杂度：O(n)。 🏠 空间复杂度：O(n)。 > 我们看到进阶里提到了空间复杂度O(1)，这就涉及到非常巧妙的一个双指针做法。下图是一种比较典型的情况下，做的推导[4]： ![双指针法环形链表 [4]](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/542346e280aa4af5958e91cbcaeaad03~tplv-k3u1fbpfcp-zoom-1.image) 代码实现： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 142. 环形链表 II * @author 三分恶 * @date 2021/7/25 20:52 */ public ListNode detectCycle(ListNode head) { if (head == null || head.next == null) { return null; } //定义快、慢指针 ListNode fast = head, slow = head; while (fast != null && fast.next != null) { fast = fast.next.next; slow = slow.next; //快慢指针相遇 if (fast == slow) { //快指针重回head fast = head; while (slow != fast) { fast = fast.next; slow = slow.next; } return fast; } } return null; } ```` ⏰ 时间复杂度：O(n)。 🏠 空间复杂度：O(1)。 # 双链表问题 ## [LeetCode86. 分隔链表](https://leetcode-cn.com/problems/partition-list/) ☕ 题目：86. 分隔链表 (https://leetcode-cn.com/problems/partition-list/) ❓ 难度：中等 📕 描述：给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。 ![示例](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ecba7b4674e54328bf0e623443fdccf3~tplv-k3u1fbpfcp-zoom-1.image) 💡 思路：可以创建两个链表，一个链表存小节点，一个链表存大节点，最后再把两个链表合并起来。代码如下： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 86. 分隔链表 * @author 三分恶 * @date 2021/7/25 21:58 */ public ListNode partition(ListNode head, int x) { if (head == null) { return null; } //定义两个新链表 ListNode small = new ListNode(-1); ListNode big = new ListNode(-1); //小、大链表头节点 ListNode smallHad = small; ListNode bigHead = big; ListNode cur = head; while (cur != null) { if (cur.val < x) { //小链表插入节点 small.next = cur; small = small.next; } else { //大链表插入节点 big.next = cur; big = big.next; } cur = cur.next; } //防止成环 big.next = null; //合并链表 small.next = bigHead.next; return smallHad.next; } ```` ⏰ 时间复杂度：O(n)。 ## [LeetCode328. 奇偶链表](https://leetcode-cn.com/problems/odd-even-linked-list/) ☕ 题目：328. 奇偶链表 (https://leetcode-cn.com/problems/odd-even-linked-list/) ❓ 难度：中等 📕 描述：给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。示例 1: ```` 输入: 1->2->3->4->5->NULL 输出: 1->3->5->2->4->NULL ```` 示例 2: ```` 输入: 2->1->3->5->6->4->7->NULL 输出: 2->3->6->7->1->5->4->NULL ```` **说明:** - 应当保持奇数节点和偶数节点的相对顺序。 - 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。 💡 思路：和上道题类似，我们也是将新建两个链表，分别保存奇、偶数位的节点，然后再把两个链表拼起来。 ![奇偶链表](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/77037d7cf6b14efb93ecab70992a9424~tplv-k3u1fbpfcp-zoom-1.image) 代码如下： ````java /** * @return 奇偶链表 * @Description: * @author 三分恶 * @date 2021/7/25 22:18 */ public ListNode oddEvenList(ListNode head) { if (head == null) { return null; } //奇数位链表 ListNode odd = new ListNode(-1); //偶数位链表 ListNode even = new ListNode(-1); //奇、偶链表头 ListNode oddHead = odd; ListNode evenHead = even; //计算位置 int index = 1; //遍历 ListNode cur = head; while (cur != null) { // 奇 if (index % 2 == 1) { odd.next = cur; odd = odd.next; } else { //偶 even.next = cur; even = even.next; } index++; cur = cur.next; } //防止成环 even.next = null; //合并链表 odd.next = evenHead.next; return oddHead.next; } ```` ⏰ 时间复杂度：O(n)。 ## [剑指 Offer 25. 合并两个排序的链表](https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/) ☕ 题目：剑指 Offer 25. 合并两个排序的链表(https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/) ❓ 难度：简单 📕 描述：输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 **示例1：** ````java 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 ```` 本题与主站 21 题相同：https://leetcode-cn.com/problems/merge-two-sorted-lists/ 💡 思路：两个升序链表，需要将其合并，那么我们需要创建一个新链表，遍历两个链表，把小的那个接在后面。代码如下： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 剑指 Offer 25. 合并两个排序的链表 * @author 三分恶 * @date 2021/7/25 22:36 */ public ListNode mergeTwoLists(ListNode l1, ListNode l2) { //新链表 ListNode newNode = new ListNode(-1); //新链表伪头 ListNode newHead = newNode; while (l1 != null && l2 != null) { //插入小的节点 if (l1.val <= l2.val) { newNode.next = l1; l1 = l1.next; } else { newNode.next = l2; l2 = l2.next; } newNode = newNode.next; } //最后一个节点不要漏了 newNode.next = l1 != null ? l1 : l2; return newHead.next; } ```` ⏰ 时间复杂度：O(n)。 ## [面试题 02.05. 链表求和](https://leetcode-cn.com/problems/sum-lists-lcci/) ☕ 题目：面试题 02.05. 链表求和 (https://leetcode-cn.com/problems/sum-lists-lcci/) ❓ 难度：中等 📕 描述：给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。 **示例：** ```` 输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295 输出：2 -> 1 -> 9，即912 ```` **进阶：**思考一下，假设这些数位是正向存放的，又该如何解决呢? **示例：** ```` 输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295 输出：9 -> 1 -> 2，即912 ```` 💡 思路：这个就是我们上小学的时候很熟悉的四则运算。两个链表从头，也就是个位开始计算，计算的结果，需要进位，我们用一个新链表来保存运算的结果。如图： ![链表求和](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b5cf3debc9c345eb8918771319b2d11d~tplv-k3u1fbpfcp-zoom-1.image) 代码实现如下： ````java /** * @return cn.fighter3.linked_list.ListNode * @Description: 面试题 02.05. 链表求和 * @author 三分恶 * @date 2021/7/26 2:40 */ public ListNode addTwoNumbers(ListNode l1, ListNode l2) { //新链表 ListNode newNode = new ListNode(-1); //新链表头 ListNode newHead = newNode; //用来保存进制位 int carry = 0; while (l1 != null || l2 != null) { //判断当前位是否为空，为空则设置为0 int l1Num = l1 == null ? 0 : l1.val; int l2Num = l2 == null ? 0 : l2.val; //求和 int sum = l1Num + l2Num + carry; //更新进位 carry = sum / 10; //求节点值 int nodeNum = sum % 10; //添加节点 newNode.next = new ListNode(nodeNum); //移动新链表指针 newNode = newNode.next; //移动两个链表指针 if (l1 != null) { l1 = l1.next; } if (l2 != null) { l2 = l2.next; } } //最后根据进位，确定是否需要在尾部添加节点 if (carry != 0) { newNode.next = new ListNode(carry); } return newHead.next; } ```` ⏰ 时间复杂度：O(n)。 # 总结总结，我随手写了个顺口溜。 ![链表总结](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e25fe6e2374747ae93cba454f3681592~tplv-k3u1fbpfcp-zoom-1.image) > 简单的事情重复做，重复的事情认真做，认真的事情有创造性地做！ > > 我是``三分恶``，一个能文能武的全栈开发。 > > ``点赞``、``关注``不迷路，大家下期见！

博主是一个算法萌新，刷题路线和思路主要参考以下大佬！建议关注！ 参考： [1].https://github.com/youngyangyang04/leetcode-master [2].https://github.com/chefyuan/algorithm-base [3].https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/lang-man-ai-qing-gu-shi-zou-yi-zou-dui-f-35vn/ [4].https://leetcode-cn.com/problems/linked-list-cycle-ii/solution/xiang-xi-tu-jie-ken-ding-kan-de-ming-bai-by-xixili/