当前位置：首页 > news >正文

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

news 来源：原创 2025/9/19 3:00:12

算法学习：

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.引入虚拟“头"结点

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

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

判环
找链表中环的入口
找链表中倒数第 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

算法原理：

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

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

代码实现：

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;i<k;i++){           ListNode* next=cur->next;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. 总结

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

本篇笔记：

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

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

1.1 链表的常用技巧

1.2 链表的常用操作

2. 有关链表的经典题型

2.1 两数相加

2.2 两两交换链表中的节点

2.3 重排链表

2.4 K个一组翻转链表

3. 总结

相关文章：