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。

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

javascript 复制代码

/**
 * 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 遍历链表，当遇到目标节点时，调整指针跳过该节点并释放内存。

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

javascript 复制代码

/**
 * 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 的节点依次尾插到新链表中，最后返回新链表的头指针。

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

javascript 复制代码

/**
 * 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 指针指向前驱节点，最终实现链表反转。

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

javascript 复制代码

/**
 * 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)，仅需常数级额外空间存储指针变量。

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

思路分析

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

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

javascript 复制代码

/**
 * 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)，需要创建新链表。

总结

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

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

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

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

方 法 一 - - - 原 地 删 除

方 法 二 - - - 双 指 针

方 法 三 - - - 尾 插

第 二 题 - - - 反 转 链 表

方 法 一 - - - 迭 代

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

总 结

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

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

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

方法一 - - - 原地删除

方法二 - - - 双指针

方法三 - - - 尾插

第二题 - - - 反转链表

方法一 - - - 迭代

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

总结