> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。> 目标：熟练掌握链表算法。
> 毒鸡汤：学习，学习，再学习 ! 学，然后知不足。
> 专栏选自：刷题训练营
> 望小伙伴们点赞👍收藏✨加关注哟💕💕
🌟前言分析
最早博主续写了牛客网130道题，这块的刷题是让同学们快速进入C语言，而我们学习c++已经有一段时间了，知识储备已经足够了但缺少了实战，面对这块短板博主续写刷题训练，针对性学习，把相似的题目归类，系统的刷题，而我们刷题的官网可以参考：
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决_牛客网
⭐知识讲解
基本思想：
- 画图，一定要画图，只有画好图才能直观形象便于我们理解。
- 引入虚拟"头"结点。
- 不要吝啬空间，大胆去定义变量。
🌙topic-->1
题目链接：1. 两数相加 - 力扣（LeetCode）
题目分析：
给一个非空的链表，表示的是两个非负的整数，它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字，然后将两个数字相加，并以相同形式返回一个表示和的链表。
算法原理：
- 解法：模拟两数相加的过程即可
图解：
细节处理：
- 判端循环结束标志。
- 可能存在两个链表长短不一。
- 不要忘记释放空间。
代码演示：
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 = t + cur1->val;
cur1 = cur1->next;// 指针需要移动
}
// 再加上第二个链表
if(cur2)
{
t = t + cur2->val;
cur2 = cur2->next;// 指针需要移动
}
// 开始进位
prev->next = new ListNode(t % 10);
prev = prev->next;
t = t/10;
}
prev = newhead->next; // 回到最初位置
delete newhead;// 释放空间
return prev;
}
};🌙topic-->2
题目链接：2. 两两交换链表中的节点 - 力扣（LeetCode）
题目分析：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题。
算法原理：
- 解法一：采用递归（有兴趣大家自己可以上手写写）
- 解法二：循环+迭代（模拟）
图解：
细节处理：
- 判断链表边界情况。
- 循环结束标志。
- 不要忘记释放空间。
代码演示：
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;
}
};🌙topic-->3
题目链接：3. 重排链表 - 力扣（LeetCode）
题目分析：
给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
算法原理：
- 解法：模拟
图解：
无
细节处理：
- 判断链表边界情况。
代码演示：
class Solution
{
public:
void reorderList(ListNode* head)
{
// 处理边界情况
if (head == nullptr || head->next == nullptr || head->next->next == nullptr)
return;
// 1. 找到链表的中间节点 - 快慢双指针（⼀定要画图考虑 slow
// 的落点在哪⾥）
ListNode *slow = head, *fast = head;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
// 2. 把 slow 后⾯的部分给逆序 - 头插法
ListNode* head2 = new ListNode(0);
ListNode* cur = slow->next;
slow->next = nullptr; // 注意把两个链表给断开
while (cur)
{
ListNode* next = cur->next;
cur->next = head2->next;
head2->next = cur;
cur = next;
}
// 3. 合并两个链表 - 双指针
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;
prev = prev->next;
cur2 = cur2->next;
}
}
delete head2;
delete ret;
}
};🌙topic-->4
题目链接：4. 合并 K 个升序链表 - 力扣（LeetCode）
题目分析：
给你一个链表数组，每个链表都已经按升序排列，请你将所有链表合并到一个升序链表中，返回合并后的链表。
算法原理：
- 解法：递归+分治
图解：
代码演示：
class Solution
{
public:
ListNode* mergeKLists(vector<ListNode*>& lists)
{
return merge(lists, 0, lists.size() - 1);
}
ListNode* merge(vector<ListNode*>& lists, int left, int right)
{
if(left > right) return nullptr;
if(left == right) return lists[left];
// 1. 平分数组
int mid = left + right >> 1;
// [left, mid] [mid + 1, right]
// 2. 递归处理左右区间
ListNode* l1 = merge(lists, left, mid);
ListNode* l2 = merge(lists, mid + 1, right);
// 3. 合并两个有序链表
return mergeTowList(l1, l2);
}
ListNode* mergeTowList(ListNode* l1, ListNode* l2)
{
if(l1 == nullptr) return l2;
if(l2 == nullptr) return l1;
// 合并两个有序链表
ListNode head;
ListNode* cur1 = l1, *cur2 = l2, *prev = &head;
head.next = nullptr;
while(cur1 && cur2)
{
if(cur1->val <= cur2->val)
{
prev = prev->next = cur1;
cur1 = cur1->next;
}
else
{
prev = prev->next = cur2;
cur2 = cur2->next;
}
}
if(cur1) prev->next = cur1;
if(cur2) prev->next = cur2;
return head.next;
}
};🌙topic-->5
题目链接：5. K 个一组翻转链表 - 力扣（LeetCode）
题目分析：
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
算法原理：
- 解法：模拟
图解：
代码演示：
class Solution
{
public:
ListNode* reverseKGroup(ListNode* head, int k)
{
// 1. 先求出需要逆序多少组
int n = 0;
ListNode* cur = head;
while(cur)
{
cur = cur->next;
n++;
}
n /= k;
// 2. 重复 n 次：⻓度为 k 的链表的逆序即可
ListNode* newHead = new ListNode(0);
ListNode* prev = newHead;
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;
}
};🌟结束语
今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。
![[渗透测试学习] Runner-HackTheBox](https://img-blog.csdnimg.cn/direct/14add2793aab445bb9a5a0d30fd97196.png)
