【算法学习】链表篇：链表的常用技巧和操作总结_链表的 经典操作

算法学习：

https://blog.csdn.net/2301_80220607/category_12922080.html?spm=1001.2014.3001.5482

前言：

在各种数据结构中，链表是最常用的几个之一，熟练使用链表和链表相关的算法，可以让我们在处理很多问题上都更加容易，下面我们就开始通过一些经典例题学习链表相关的算法

目录

1. 链表的常用技巧和常用操作

1.1 链表的常用技巧

1.2 链表的常用操作

2. 有关链表的经典题型

2.1 两数相加

2.2 两两交换链表中的节点

2.3 重排链表

2.4 K个一组翻转链表

3. 总结

1. 链表的常用技巧和常用操作

1.1 链表的常用技巧

1.画图!!! -> 直观 + 形象 + 便于我们理解

2.引入虚拟“头\"结点

1.   便于处理边界情况
2.   方便我们对链表操作

3.不要吝啬空间，大胆去定义变量
4.快慢双指针

1. 判环
2. 找链表中环的入口
3. 找链表中倒数第 n个结点

在做链表链表题时，我们尽量把思路画下来，能够更直观的看到问题所在，同时能引入虚拟头节点就引入虚拟头节点，可以帮助我们处理边界情况

链表中最基础的算法之一就是快慢双指针的使用，熟练掌握可以帮助我们解决很多问题

1.2 链表的常用操作

• 1.创建一个新节点 new
• 2.尾插
• 3.头插（逆序链表的题经常会用到)
   

头插法的具体操作：

以上四步要一步一步来，顺序不能有误

2. 有关链表的经典题型

2.1 两数相加

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]输出：[7,0,8]解释：342 + 465 = 807.

提示：

• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

我们先来结合一个例子理解一下这里的逆序是如何操作的：

其实将数字逆序比正序容易，数字逆序后，我们按照链表相加时，先加个位，再加十位，依次往后相加，符合加法逻辑，所以如果是正序的话我们反倒还需要先将链表颠倒，让它变成逆序后再操作

我们可以结合代码来看一下这个原理图，首先我们需要定义一个整数t，它的作用就是计算链表同一位置两数的和，其实对应的就是加法中的相同权值的位置相加(比如个位+个位)，然后将t的个位放入求和链表中的相同位置，t如果十位不为0，代表的其实是要进位，比如上面例子中4+6=10，那么个位是0，我们将0放入求和链表的第二个节点处，t的十位跟随cur1、cur2一起来到权值更高的下一个节点进行新的相加运算

代码实现：

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); t/=10; prev=prev->next; } prev=newhead->next; delete newhead; return prev; }};

2.2 两两交换链表中的节点

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]输出：[2,1,4,3]

示例 2：

输入：head = []输出：[]

示例 3：

输入：head = [1]输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

这种解法就比较简单粗暴了，就是直接创建一个全新的链表，将原链表中的值按要求交换后输入这个链表中，这样做的好处就是思路简单，容易想到，缺点就是空间开销大

class Solution {public: ListNode* swapPairs(ListNode* head) { if(head==nullptr||head->next==nullptr) return head; ListNode* newhead=swapPairs(head->next->next); ListNode* tmp=head->next; head->next->next=head; head->next=newhead; //head->next=tmp->next; //tmp->next=head; return tmp; }};

这种解法就是上面的那种解法，观察上面的图，简单点来说就是还是在原链表上进行操作，记得处理好边界情况，记得创建一个头节点(方便我们找到链表的其实位置，返回值时简单)

2.3 重排链表

143. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1,2,3,4]输出：[1,4,2,3]

示例 2：

输入：head = [1,2,3,4,5]输出：[1,5,2,4,3]

提示：

• 链表的长度范围为 [1, 5 * 104]
• 1 <= node.val <= 1000

算法原理：

主要思路如图所示，这个题目像让我们做的就是链表头取出一个数字，然后再从链表尾取一个数字直到最后取到中间为止，所以我们可以如上图所示，把链表从中间分为两个，然后将后面的逆序然后合并两个链表即可

代码实现：

class Solution {public: void reorderList(ListNode* head) { //处理边界情况 if(head->next==nullptr||head->next->next==nullptr) return; //1. 找到链表的中间节点 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; prev=prev->next; cur1=cur1->next; //再放第二个链表 if(cur2){ prev->next=cur2; prev=prev->next; cur2=cur2->next; } } head=ret->next; }};

2.4 K个一组翻转链表

25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2输出：[2,1,4,3,5]

示例 2：

输入：head = [1,2,3,4,5], k = 3输出：[3,2,1,4,5]

提示：

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

算法原理：

主要的解题方法就是上面的那两步
   但是这里也有一些细节需要我们注意:

1. 每一轮逆序结束后，我们在下一轮头插时记得要在返回链表的尾部进行头插
2. 在逆序结束后，如果还有剩余的节点记得带上

代码实现：

class Solution {public: ListNode* reverseKGroup(ListNode* head, int k) { //1. 计算链表中节点个数 int n=0; ListNode* cur=head; while(cur) { n++; cur=cur->next; } int count=n/k; ListNode* ret=new ListNode(0); ListNode* prev=ret; cur=head; while(count--) { ListNode* tmp; for(int i=0;inext; cur->next=prev->next; prev->next=cur; if(i==0) tmp=cur; cur=next; } prev=tmp; } while(cur){ prev->next=cur; prev=prev->next; cur=cur->next; } return ret->next; }};

3. 总结

以上就是几个经典的链表的例题，通过这几道题，其实我们应该明白的是，要想做好链表相关的题，就一定要把有关链表的基础算法给掌握好，比如如何逆序链表，如何实现头插尾插，如何使用快慢双指针等，把这些基础算法掌握好，然后结合题意，大部分链表题还是能够拿下的

本篇笔记：

感谢各位大佬观看，创作不易，还望各位大佬点赞支持！！！