| 算法 | 相关知识点 | 可以通过点击 | 以下链接进行学习 | 一起加油！ |
|---|---|---|---|---|
| 双指针 | 滑动窗口 | 二分查找 | 前缀和 | 位运算 |
| 模拟 |
链表是一种灵活的数据结构，广泛用于需要频繁插入和删除的场景。掌握链表的常见操作技巧，如插入、删除、翻转和合并等，能帮助开发者更高效地解决实际问题。接下来，我们将探讨一些常见的链表算法及其应用。
🌈个人主页：是店小二呀
🌈Linux专栏： Linux
🌈算法专栏：算法
🌈Mysql专栏:Mysql
🌈你可知:无人扶我青云志 我自踏雪至山巅
文章目录
- 链表常用技巧和操作总结
-
- a.常用技巧
- b.链表中的常用操作
- 2.两数相加
- 24.两两交换链表中的节点
- 143.重排链表
- [23.合并 K 个升序链表](#23.合并 K 个升序链表)
- [25.K 个一组翻转链表](#25.K 个一组翻转链表)
链表常用技巧和操作总结
a.常用技巧
1.画图(直观 + 形象)，便于我们理解
2.引入虚拟"头"节点
a.便于处理边界情况
b.方便我们对于链表操作，处理方式跟后续节点方式统一
3.不要吝啬空间，大胆去定义变量，简洁节点链接表达方式
b.链表中的常用操作
创建一个新节点 new
尾插操作
头插操作(逆序链表)
2.两数相加
【题目 】：2. 两数相加
【算法思路】
逆序'关键字表明链表已经完成了逆序操作。在链表相加的题目中，通常也需要先将链表逆序，因为加法操作是从最低位开始的，相当于模拟竖式加法。因此，为了正确执行加法操作，链表需要先进行逆序处理。
解法：模拟两数相加的过程
如果不创建虚拟头节点，就需要将两数相加的结果作为一个头节点，这样会导致计算顺序不够简洁，需要先计算结果，再将后续的节点相加，增加了一些额外的步骤。相比之下，先创建虚拟头节点可以直接开始加法操作，模拟加法时进位 t = 0，这样整个过程更加直观且高效。使用头插法可以简化这一过程。
【代码实现】
cpp
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。
【代码实现】
cpp
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 。
cpp
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)就行。
cpp
//合并两个链表
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;
}
}【代码实现】
cpp
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 问题的思路，利用优先级队列（小堆）来高效地找出最小节点，从而降低时间复杂度。
【代码实现】
cpp
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 个节点，将首节点头插后，它将成为链表的最后一个节点。为了清晰理解，可以通过绘图展示链表的变化过程。
【代码实现】
cpp
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;
}
};
快和小二一起踏上精彩的算法之旅！关注我，我们将一起破解算法奥秘，探索更多实用且有趣的知识，开启属于你的编程冒险！