1. 手把手刷链表算法

双指针秒杀7道链表题目
- 合并两个有序链表
- 合并 k 个有序链表
- 单链表的倒数第 k 个节点
- 单链表的中点
- 判断链表是否包含环
- 链表中环的入口节点
- 两个链表是否相交
递归反转链表的一部分
- 反转链表
- 反转链表前N个节点
- 反转链表II
如何K个一组反转链表
如何判断回文链表

双指针秒杀7道链表题目

链接: labuladong的算法小抄.

合并两个有序链表

力扣: 合并两个有序链表.

class Solution {public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {ListNode* dummy = new ListNode(-1), *p = dummy;ListNode* p1 = list1, *p2 = list2;while (p1 != nullptr && p2 != nullptr) {// 比较 p1 和 p2 两个指针// 将值较小的节点接到 p 指针if (p1->val > p2->val) {p->next = p2;p2 = p2->next;} else {p->next = p1;p1 = p1->next;}p = p->next;}if (p1 != nullptr) {p->next = p1;} if (p2 != nullptr) {p->next = p2;}return dummy->next;}
};

合并 k 个有序链表

力扣: 合并k个有序链表.

class Solution {public:ListNode* mergeKLists(vector<ListNode*>& lists) {// 优先队列，最小堆 无论入队顺序如何，都是当前最小的元素优先出队priority_queue<int> q;// 将所有值直接放入优先队列中for (ListNode* &t : lists) {while (t) {q.push(t->val);t = t->next;}}ListNode *last = NULL;while (!q.empty()) {ListNode *p = new ListNode(q.top());q.pop();p->next = last;last = p;}return last;}
};

单链表的倒数第 k 个节点

力扣: 单链表的倒数第 k 个节点.

class Solution {public:ListNode* getKthFromEnd(ListNode* head, int k) {ListNode* fast = head;ListNode* later = head;while (fast && k > 0) {fast = fast->next;k--;}while (fast) {fast = fast->next;later = later->next;}return later;}
};

单链表的中点

链接: 单链表的中点.

class Solution {public:ListNode* middleNode(ListNode* head) {ListNode* fast = head, *slow = head;while (fast != nullptr && fast->next != nullptr) {slow = slow->next;fast = fast->next->next;}return slow;}
};

判断链表是否包含环

链接: 判断链表是否包含环.

class Solution {public:bool hasCycle(ListNode *head) {// 快慢指针初始化指向 headListNode* fast = head, *slow = head;// 快指针走到末尾时停止while (fast != nullptr && fast->next != nullptr) {// 慢指针走一步，快指针走两步slow = slow->next;fast = fast->next->next;// 快慢指针相遇，说明含有环if (fast == slow) {return true;}}// 不包含环return false;}
};

链表中环的入口节点

进阶：链接: 链表中环的入口节点.

class Solution {public:ListNode *detectCycle(ListNode *head) {ListNode* fast = head, *slow = head;while (fast != nullptr && fast->next != nullptr) {slow = slow->next;fast = fast->next->next;if (fast == slow) break;}if (fast == nullptr ||fast->next == nullptr) {return nullptr;}slow = head;while (fast != slow) {slow = slow->next;fast = fast->next;}return slow;}
};

两个链表是否相交

链接: 两个链表是否相交.

class Solution {public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {// p1 指向 A 链表头结点，p2 指向 B 链表头结点ListNode* p1 = headA, *p2 = headB;while (p1 != p2) {// p1 走一步，如果走到 A 链表末尾，转到 B 链表if (p1 == nullptr) p1 = headB;else p1 = p1->next;// p2 走一步，如果走到 B 链表末尾，转到 A 链表if (p2 == nullptr) p2 = headA;else p2 = p2->next;}return p1;}
};

递归反转链表的一部分

反转链表

链接: 反转链表.

class Solution {public:ListNode* reverseList(ListNode* head) {// 链表为空，返回，如果链表只有一个节点的时候反转也是它自己，返回。if (head == nullptr || head->next == nullptr) {return head;}ListNode* last = reverseList(head->next);head->next->next = head;head->next = nullptr;return last;}
};

反转链表前N个节点

ListNode* successor = null; // 后驱节点// 反转以 head 为起点的 n 个节点，返回新的头结点
ListNode reverseN(ListNode *head, int n) {if (n == 1) {// 记录第 n + 1 个节点successor = head->next;return head;}// 以 head.next 为起点，需要反转前 n - 1 个节点ListNode* last = reverseN(head->next, n - 1);head->next->next = head;// 让反转之后的 head 节点和后面的节点连起来head->next = successor;return last;
}

反转链表II

链接: 反转链表II.

给一个索引区间 [m,n]（索引从 1 开始），仅仅反转区间中的链表元素。

如果 m != 1 怎么办？如果我们把 head 的索引视为 1，那么我们是想从第 m 个元素开始反转对吧；如果把 head.next 的索引视为 1 呢？那么相对于 head.next，反转的区间应该是从第 m - 1 个元素开始的；那么对于 head.next.next 呢……

class Solution {public:ListNode* reverseBetween(ListNode* head, int left, int right) {// base caseif (left == 1) {return reverseN(head, right);}// 前进到反转的起点触发 base casehead->next = reverseBetween(head->next, left - 1, right - 1);return head;}ListNode* successor = nullptr; // 后驱节点// 反转以 head 为起点的 n 个节点，返回新的头结点ListNode* reverseN(ListNode *head, int right) {if (right == 1) {// 记录第 n + 1 个节点successor = head->next;return head;}// 以 head.next 为起点，需要反转前 n - 1 个节点ListNode* last = reverseN(head->next, right - 1);head->next->next = head;// 让反转之后的 head 节点和后面的节点连起来head->next = successor;return last;}
};

如何K个一组反转链表

链接: 如何K个一组反转链表.

class Solution {public:/** 反转区间 [a, b) 的元素，注意是左闭右开 */ListNode* reverse(ListNode* a, ListNode* b) {ListNode* pre = nullptr, *cur = a, *next = a;while (cur != b) {next = cur->next;cur->next = pre;pre = cur;cur = next;}return pre;}ListNode* reverseKGroup(ListNode* head, int k) {if (head == nullptr) return nullptr;// 区间 [a, b) 包含 k 个待反转元素ListNode* a, *b;a = b = head;for (int i = 0; i < k; i++) {// 不足 k 个，不需要反转，base caseif (b == nullptr) return head;b = b->next;}// 反转前 k 个元素ListNode* newNode = reverse(a, b);a->next = reverseKGroup(b, k);return newNode;}
};

如何判断回文链表

链接: 如何判断回文链表.

class Solution {public:bool isPalindrome(ListNode* head) {ListNode* fast = head, *slow = head;while (fast != nullptr && fast->next != nullptr) {slow = slow->next;fast = fast->next->next;}if (fast != nullptr) {slow = slow->next;}ListNode* left = head;ListNode* right = reverse(slow);while (right != nullptr) {if (left->val != right->val) {return false;}left = left->next;right = right->next;}return true;}ListNode* reverse(ListNode* head) {ListNode *pre = nullptr, *cur = head, *next = head;while (cur != nullptr) {next = cur->next;cur->next = pre;pre = cur;cur = next;}return pre;}
};

手把手刷数据结构-1.手把手刷链表算法相关推荐

平板电脑如何刷linux,手把手教你六步刷系统
· 手把手教你六步刷系统当一切准备就绪后,就可以开始刷机了,首先要用USB2.0接口数据线连接电脑与神舟LiPad T10,然后在关机状态下同时按下上文中介绍的A按键与B按键,这时Windows系统 ...
小米 android 7.0彩蛋,手把手教你小米怎么刷入安卓7.0！
原标题:手把手教你小米怎么刷入安卓7.0! 小米3/4/Note用上原生Android 7.0,还不赶快升级?手把手教你小米怎么刷入安卓7.0! Android 7.0发布已数月,但国内仅有华为EMU ...
为了OFFER，花了几个小时，刷下Leetcode链表算法题
@Author:Runsen @Date:2020/9/13 链表是我这辈子的痛啊,每次学到链表,就往往不会,就没有继续学下去.现在大四不能继续让这个链表阻碍我了.现在基本是重刷数据结构和算法,毕竟笔 ...
外包3年,吃透这三份Java程序员必刷的算法宝典后,已从13K涨到25K
懂点算法,很有必要 "不学数据结构和算法,一辈子都是码畜".不管你是 Java 程序员.算法工程师.数据分析师,还是技术管理者.架构师...... 我们都有一个共同的目标,就是在技 ...
数据结构 - 链表 - 面试中常见的链表算法题
数据结构 - 链表 - 面试中常见的链表算法题数据结构是面试中必定考查的知识点,面试者需要掌握几种经典的数据结构:线性表(数组.链表).栈与队列.树(二叉树.二叉查找树.平衡二叉树.红黑树).图. ...
数据结构上机实践第四周项目4 - 建设双链表算法库
数据结构之自建算法库--双链表各种算法结构都有各自的用途,在实际中我们会碰到各种工程,单链表有时无法或者不能很好的满足我们的需求,这个时候,双链表不失为一种好的数据结构.本次实践将建立双链表算法库, ...
DSt：数据结构的最强学习路线之数据结构知识讲解与刷题平台、刷题集合、问题为导向的十大类刷题算法(数组和字符串、栈和队列、二叉树、堆实现、图、哈希表、排序和搜索、动态规划/回溯法/递归/贪心/分治)总
DSt:数据结构的最强学习路线之数据结构知识讲解与刷题平台.刷题集合.问题为导向的十大类刷题算法(数组和字符串.栈和队列.二叉树.堆实现.图.哈希表.排序和搜索.动态规划/回溯法/递归/贪心/分治)总 ...
数据结构——常见链表算法题
数据结构--常见链表算法题(C++运行) 本文介绍常见的有关链表的算法题,值得一提的是,该代码无需在力扣上,可在本地运行成功. 题目八道: 1.反转链表 2.移除链表中的重复节点 3.查找链表中的中间 ...
ACM金牌导师1个月带你一起魔鬼刷爆算法题！
金牌导师带你刷爆算法算法知识一个月讲解+训练今天限时特价参加在讲到 AI 算法工程师时,大部分同学关注点都在高大上的模型,一线优秀的项目.但大家往往忽略了一点,人工智能的模型.项目最终还是要 ...
为进大厂刷爆算法题，最后却倒在了基础题上？太苦了！
金牌导师带你刷爆算法算法知识一个月讲解+训练今天限时特价参加在讲到 AI 算法工程师时,大部分同学关注点都在高大上的模型,一线优秀的项目.但大家往往忽略了一点,人工智能的模型.项目最终还是要 ...

手把手刷数据结构-1.手把手刷链表算法