【优选算法 | 链表】链表操作技巧:常见算法_链表所有的方法
链表是一种灵活的数据结构，广泛用于需要频繁插入和删除的场景。掌握链表的常见操作技巧，如插入、删除、翻转和合并等，能帮助开发者更高效地解决实际问题。接下来，我们将探讨一些常见的链表算法及其应用。
🌈个人主页：是店小二呀
🌈C/C++专栏：C语言\\ C++
🌈初/高阶数据结构专栏： 初阶数据结构\\ 高阶数据结构
🌈Linux专栏： Linux
🌈算法专栏：算法
🌈Mysql专栏:Mysql
🌈你可知:无人扶我青云志 我自踏雪至山巅
文章目录
- 链表常用技巧和操作总结
-
- a.常用技巧
- b.链表中的常用操作
- 2.两数相加
- 24.两两交换链表中的节点
- 143.重排链表
- 23.合并 K 个升序链表
- 25.K 个一组翻转链表
链表常用技巧和操作总结
a.常用技巧
1.画图(直观 + 形象)，便于我们理解
2.引入虚拟\"头\"节点
a.便于处理边界情况
b.方便我们对于链表操作，处理方式跟后续节点方式统一
3.不要吝啬空间，大胆去定义变量，简洁节点链接表达方式
b.链表中的常用操作
创建一个新节点 new
尾插操作
头插操作(逆序链表)
2.两数相加
【题目】：2. 两数相加
【算法思路】
逆序’关键字表明链表已经完成了逆序操作。在链表相加的题目中，通常也需要先将链表逆序，因为加法操作是从最低位开始的，相当于模拟竖式加法。因此，为了正确执行加法操作，链表需要先进行逆序处理。
解法：模拟两数相加的过程
如果不创建虚拟头节点，就需要将两数相加的结果作为一个头节点，这样会导致计算顺序不够简洁，需要先计算结果，再将后续的节点相加，增加了一些额外的步骤。相比之下，先创建虚拟头节点可以直接开始加法操作，模拟加法时进位 t = 0，这样整个过程更加直观且高效。使用头插法可以简化这一过程。
【代码实现】
class Solution {public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode * cur1 = l1, * cur2 = l2; ListNode * newhead = new ListNode(0); ListNode * prev = newhead; int t = 0; while(cur1 || cur2 || t) { if(cur1) { t += cur1 -> val; cur1 = cur1->next; } if(cur2) { t += cur2 -> val; cur2 = cur2 -> next; } prev -> next = new ListNode(t % 10); prev = prev -> next; t /= 10; } prev = newhead -> next; delete newhead; return prev; }};【细节问题】：while(cur1 || cur2 || t)，出现下面这种情况，进位是需要被考虑的。
24.两两交换链表中的节点
【题目】：24. 两两交换链表中的节点
【算法思路】
解法一：递归
解法二：循环、迭代(模拟)
题目要求涉及链表间指向转化，可以使用到我们的技巧\"不要吝啬空间，大胆去定义变量，简洁节点链接表达方式\"，这里同样需要创建虚拟\"头\"节点，便于我们进行运算操作，通过绘图，我们可以很直观知道模拟过程
【细节问题】
循环结束条件就是cur == nullptr && next == nullptr。
【代码实现】
class Solution {public: ListNode* swapPairs(ListNode* head) { if(head == nullptr || head -> next == nullptr) return head; ListNode * newHead = new ListNode(0); newHead ->next = head; ListNode * prev = newHead, * cur = prev -> next, * next = cur -> next, * nnext = next -> next; while(cur && next) { //交换操作 prev -> next = next; next -> next = cur; cur -> next = nnext; //指针转化操作 prev = cur; cur = nnext; if(cur) next = cur -> next; if(next) nnext = next -> next; } cur = newHead ->next; delete newHead; return cur; }};143.重排链表
【题目】：143. 重排链表
【算法思路】
解法:模拟
通过绘图分析，我们可以将问题分为三个问题。
【1.找到链表的中间节点】
slow慢指针走一步，fast快指针走两步，判断结束条件为fast && fast->next 。
if(head == nullptr || head -> next == nullptr || head -> next -> next == nullptr) return; //1.快慢指针找到中间节点 ListNode * slow = head; ListNode * fast = head; while(fast && fast ->next) { slow = slow -> next; fast = fast ->next ->next; }【2.将后续部分逆序】
这里可以使用双指针(三指针)，头插法。
这里咱们需要解决是，从slow->next位置逆序，还是从slow位置逆序，链表长度奇偶数，是否对位置选取有影响。
这道题目比较特殊，如果是偶数，我们会发现中间部分和最后部分顺序发现没有改变，
【3.合并两个链表】
这里选择slow -> next位置逆序，链表1长度比链表2长度要长，所以外面判断条件为while(cur1)就行。
//合并两个链表 ListNode * ret = new ListNode(0); ListNode * prev = ret; ListNode * cur1 = head, * cur2 = head2 ->next; while(cur1) { prev -> next = cur1; cur1 = cur1 -> next; prev = prev -> next; if(cur2) { prev ->next = cur2; cur2 = cur2 ->next; prev = prev -> next; } }【代码实现】
class Solution {public: void reorderList(ListNode* head) { if(head == nullptr || head -> next == nullptr || head -> next -> next == nullptr) return; //1.快慢指针找到中间节点 ListNode * slow = head; ListNode * fast = head; while(fast && fast ->next) { slow = slow -> next; fast = fast ->next ->next; } //2.获得两个链表 ListNode * head2 = new ListNode(0); ListNode * cur = slow -> next; slow->next = nullptr; //3.链表逆序 while(cur) { ListNode * next = cur ->next; cur -> next = head2 ->next; head2 -> next = cur; cur = next; } //合并两个链表 ListNode * ret = new ListNode(0); ListNode * prev = ret; ListNode * cur1 = head, * cur2 = head2 ->next; while(cur1) { prev -> next = cur1; cur1 = cur1 -> next; prev = prev -> next; if(cur2) { prev ->next = cur2; cur2 = cur2 ->next; prev = prev -> next; } } delete head2; delete ret; }};23.合并 K 个升序链表
【题目】：23. 合并 K 个升序链表
【算法思路】
解法一：优先级队列
面对 K 个升序链表，每次需要找到最小节点进行插入，如果使用循环遍历，时间复杂度会变得很高。为了快速找到最小节点或最小的 K 个节点，可以借鉴 topK 问题的思路，利用优先级队列（小堆）来高效地找出最小节点，从而降低时间复杂度。
【代码实现】
class Solution {public: struct cmp { bool operator()(const ListNode* l1, const ListNode* l2) { return l1->val > l2->val; } }; ListNode* mergeKLists(vector<ListNode*>& lists) { //创建小堆 priority_queue<ListNode*, vector<ListNode*>,cmp> heap; //将每个链表头节点传入 for(auto l : lists) if(l) heap.push(l); ListNode * ret = new ListNode(0); ListNode * prev = ret; while(!heap.empty()) { ListNode * t = heap.top(); heap.pop(); prev ->next = t; prev = t; if(t ->next) heap.push(t->next); } prev = ret ->next; delete ret; return prev; }};【细节问题】:if(l) heap.push(l);如果是空节点，没有必要插入堆里面进行排序，会大幅度提高空间复杂度。
解法二：递归回溯(留到后面来写)
25.K 个一组翻转链表
【题目】：25. K 个一组翻转链表
【算法思路】
解法:模拟
面对K个什么题目，应该考虑规律性解法。这里根据题目要求，每 k 个节点一组进行翻转即可。
- 【第一步】:先求出需要逆序多少组:n
- 【第二步】：重复n次，长度为k的链表的逆序即可
使用头插法解决此问题时，考虑到需要将尾节点作为新的头节点重新插入，可以通过使用 tmp = prev 来标记。对于 k 个节点，将首节点头插后，它将成为链表的最后一个节点。为了清晰理解，可以通过绘图展示链表的变化过程。
【代码实现】
class Solution {public: ListNode* reverseKGroup(ListNode* head, int k) { if(head == nullptr && head->next == nullptr) return head; //1.需要逆序多少组 ListNode * cur = head; int n = 0; while(cur) { cur = cur-> next; n++; } n /= k; ListNode * newHead = new ListNode(0); ListNode * prev = newHead; ListNode * tmp = cur; cur = head; for(int i = 0; i < n; i++) { ListNode * tmp = cur; for(int j = 0; j < k; j++) { ListNode * next = cur->next; cur->next = prev ->next; prev->next = cur; cur = next; } prev = tmp; } prev->next = cur; cur = newHead->next; delete newHead; return cur; }};
快和小二一起踏上精彩的算法之旅！关注我，我们将一起破解算法奥秘，探索更多实用且有趣的知识，开启属于你的编程冒险！
