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

LeetCode 算法实战 - - - 移除链表元素、反转链表

news 来源：原创 2025/6/4 10:24:45

LeetCode 算法实战 - - - 移除链表元素、反转链表

第一题 - - - 移除链表元素
- 方法一 - - - 原地删除
- 方法二 - - - 双指针
- 方法三 - - - 尾插
第二题 - - - 反转链表
- 方法一 - - - 迭代
- 方法二 - - - 采用头插创建新链表
总结

💻作者简介：曾与你一样迷茫，现以经验助你入门数据结构。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：硬核数据结构与算法
✨代码趣语：恰当的数据视图实际上就决定了程序的结构。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述

在数据结构的世界里，每一种设计都可能孕育出惊人的效率变革。你是否深思过，一组精心组织的数据究竟能创造怎样的奇迹？每一次挖掘底层原理，都是与计算机智慧的巅峰对话；每一次剖析存储模式，都在破解数据世界的终极密码。准备好迎接这场盛宴了吗？让我们一同探寻双指针的无尽奥秘，见证它如何重塑数字时代的运行法则！

第一题 - - - 移除链表元素

移除链表元素

描述：给你一个链表的头节点 head 和一个整数 val，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：
输入：head = [], val = 1
输出：[ ]

示例 3：
输入：head = [7,7,7,7], val = 7
输出：[ ]

提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

方法一 - - - 原地删除

思路分析
要删除链表中值为 val 的节点，需要考虑两种情况：一是头节点的值恰好为 val；二是中间或尾部节点的值为 val。对于头节点，直接删除即可，不过要注意更新头节点；对于中间或尾部节点，需要借助前驱节点来删除当前节点。

解题步骤
删除头部的目标节点：
（1）利用循环判断头节点是否存在，并且其值是否等于 val。
（2）若满足条件，就临时保存当前头节点，将头节点更新为下一个节点，然后释放临时保存的头节点。

删除中间和尾部的目标节点：
（1）初始化 temp 指针，让它指向新的头节点（可能是原头节点，也可能是更新后的头节点）。
（2）遍历链表，确保当前节点 temp 和它的下一个节点都不为空。
（3）若下一个节点的值等于 val，则临时保存该节点，将当前节点的 next 指针指向下下个节点，最后释放临时保存的节点。
（4）若下一个节点的值不等于 val，则将 temp 指针后移一位。

返回新的头节点：
遍历结束后，返回更新后的头节点 head。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) 
{while (head != NULL && head->val == val) {struct ListNode* tmp = head;head = head->next;free(tmp);}struct ListNode* temp = head;while (temp != NULL && temp->next != NULL){if (temp->next->val == val){struct ListNode* cur = temp->next;temp->next = cur->next;free(cur);} else {temp = temp->next;}}return head;
}

复杂度分析
时间复杂度：O (n)，其中 n 为链表长度。需遍历每个节点一次。
空间复杂度：O (1)，仅需常数级额外空间存储指针变量。

以链表元素为 1,2,6,3,4,5,6 val 为 6 进行动画演示。

在这里插入图片描述

方法二 - - - 双指针

思路分析
从单链表中删除所有值等于给定值 val 的节点。主要思路是通过双指针 prev 和 cur 遍历链表，当遇到目标节点时，调整指针跳过该节点并释放内存。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) 
{struct ListNode* prev = NULL;struct ListNode* cur = head;while (cur != NULL) {if (cur->val != val) {prev = cur;cur = cur->next;} else {if (cur == head && cur->val == val) {head = cur->next;free(cur);cur = head;} else {prev->next = cur->next;free(cur);cur = prev->next;}}}return head;
}

代码分析
1、初始化双指针：
         prev：初始化为 NULL，用于记录当前节点的前一个节点。
         cur：初始化为头节点 head，用于遍历链表。
2、遍历链表：
         使用 while (cur != NULL) 循环遍历链表，直到所有节点处理完毕。
3、处理当前节点：
（1）若当前节点值不等于 val：
         将 prev 更新为 cur。
         cur 后移一位（cur = cur->next）。
（2）若当前节点值等于 val：
         若当前节点是头节点 cur == head：
              将头指针 head 后移一位 head = cur->next。
              释放当前节点内存 free(cur)。
              更新 cur 为新的头节点 cur = head。
         若当前节点不是头节点：
              通过 prev->next = cur->next 跳过当前节点。
              释放当前节点内存 free(cur)。
              更新 cur 为 prev->next。
4、返回头指针：
         遍历结束后，所有值为 val 的节点均被删除，返回新的头指针 head。

复杂度分析
时间复杂度：O (n)，其中 n 为链表长度。需遍历每个节点一次。
空间复杂度：O (1)，仅需常数级额外空间存储指针变量。

方法三 - - - 尾插

思路分析
通过遍历原链表，将不等于 val 的节点依次尾插到新链表中，最后返回新链表的头指针。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) 
{struct ListNode* cur = head;struct ListNode* newhead = NULL;struct ListNode* tail = NULL;while (cur) {if (cur->val != val) {// 尾插if (tail == NULL) {newhead = tail = cur;} else {tail->next = cur;tail = tail->next;}cur = cur->next;} else{struct ListNode* next = cur->next;free(cur);cur = next;}}if(tail){tail->next=NULL;}return newhead;
}

代码分析
1、初始化变量：
         cur：用于遍历原链表的指针，初始化为原链表头 head。
         newhead：新链表的头指针，初始化为 NULL。
         tail：新链表的尾指针，初始化为 NULL，用于高效尾插节点。
2、遍历原链表：
         使用 while (cur) 循环遍历原链表，直到所有节点处理完毕。
3、处理当前节点：
（1）若当前节点值不等于 val：
         若新链表为空（tail == NULL）：
              将 newhead 和 tail 都指向当前节点 cur。
         若新链表非空：
              将当前节点 cur 连接到新链表尾部（tail->next = cur）。
              更新 tail 为当前节点（tail = tail->next）。
              移动 cur 到下一个节点。
（2）若当前节点值等于 val：
         保存当前节点的下一个节点指针 next。
         释放当前节点内存（free(cur)），防止内存泄漏。
         将 cur 更新为 next，继续处理后续节点。
4、处理尾节点的 next 指针：
         遍历结束后，确保新链表的尾节点 tail 的 next 指针为 NULL，避免形成环。
5、返回新链表头指针：
         返回 newhead，即新链表的头节点。若原链表所有节点均被删除，newhead 为 NULL。

复杂度分析
时间复杂度：O (n)，其中 n 为链表长度。需遍历每个节点一次。
空间复杂度：O (1)，仅需常数级额外空间存储指针变量。

第二题 - - - 反转链表

反转链表

描述
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

方法一 - - - 迭代

思路分析
使用三个指针协同工作，逐步将每个节点的 next 指针指向前驱节点，最终实现链表反转。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* reverseList(struct ListNode* head) 
{struct ListNode* n1 = NULL;struct ListNode* n2 = head;struct ListNode* tmp = head;while(tmp!=NULL){tmp = n2->next;n2->next=n1;n1=n2;n2=tmp;}return n1;
}

代码分析
1、初始化三个指针：
（1）n1：初始化为 NULL，用于指向当前处理节点的前驱节点。
（2）n2：初始化为 head，指向当前正在处理的节点。
（3）tmp：初始化为 head，作为临时指针，用于保存后续节点。
2、遍历链表：
         使用 while (tmp != NULL) 循环，确保遍历完整个链表。
3、反转操作：
（1）保存后继节点：tmp = n2->next，保存当前节点的下一个节点。
（2）调整指针方向：n2->next = n1，将当前节点的 next 指向前驱节点。
（3）指针后移：
         n1 移动到当前节点（n1 = n2）。
         n2 移动到之前保存的后继节点（n2 = tmp）。
4、返回新头节点：
         循环结束后，n1 指向原链表的最后一个节点，即反转后的新头节点，返回 n1。

复杂度分析
时间复杂度：O (n)，需遍历每个节点一次。
空间复杂度：O (1)，仅需常数级额外空间存储指针变量。

方法二 - - - 采用头插创建新链表

思路分析
遍历原链表，为每个节点创建副本，创建新的链表，然后将副本节点依次插入到新链表的头部，最终形成原链表的逆序。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* reverseList(struct ListNode* head) 
{struct ListNode* cur = head;struct ListNode* newHead = NULL; //新链表的头指针while (cur) {struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));if (newNode == NULL) {perror("malloc failed");// 释放已分配的节点while (newHead) {struct ListNode* temp = newHead;newHead = newHead->next;free(temp);}return NULL;}newNode->val = cur->val;newNode->next = newHead; //头插法：新节点指向当前头newHead = newNode;       //更新头指针cur = cur->next;}return newHead; //返回新链表的头结点
}

代码分析
1、初始化变量：
         cur：指向原链表当前节点，初始化为 head。
         newHead：新链表的头指针，初始化为 NULL。
2、遍历原链表：
         使用 while (cur) 循环，直到原链表遍历完毕。
3、创建新节点并头插：
（1）分配内存：为当前节点创建副本 newNode。
（2）赋值：将原节点的值赋给新节点。
（3）头插操作：
         将新节点的 next 指向当前新链表的头结点 newHead。
         更新 newHead 为新节点，使其成为新链表的头结点。
4、错误处理：
若内存分配失败（newNode == NULL）：
         释放已创建的新链表节点（避免内存泄漏）。
         返回 NULL 表示操作失败。
5、返回结果：
         遍历结束后，newHead 指向新链表的头节点，返回 newHead。

关键技巧与注意事项
头插法的逆序特性：
         每次将新节点插入到链表头部，导致新链表节点顺序与插入顺序相反。
内存管理：
         每个新节点都通过 malloc 分配内存，需确保使用完毕后调用 free 释放。
         当内存分配失败时，需释放已分配的所有新节点，避免内存泄漏。
原链表不变：
         该方法不修改原链表结构，适合需要保留原链表的场景。

复杂度分析
时间复杂度：O (n)，遍历原链表一次。
空间复杂度：O (n)，需要创建新链表。

在这里插入图片描述

总结

至此，关于链表的探索暂告一段落，但你的编程征程才刚刚启航。编写代码是与计算机逻辑深度对话，过程中虽会在结构设计、算法实现的困境里挣扎，但这些磨砺加深了对代码逻辑和数据组织的理解。愿你合上电脑后，灵感不断，在数据结构的世界里持续深耕，书写属于自己的编程传奇，下一次开启，定有全新的精彩等待。小编期待重逢，盼下次阅读时见证你们更大的进步，共赴代码之约！