Leetcode 203. 移除链表元素

题目描述

给你一个链表的头节点 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, 10^4] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

 虚拟头节点：

移除链表元素步骤：

1. 定位要删除的节点：

   首先，需要遍历链表，找到需要移除的节点。这可以通过指针来实现，从链表的头节点开始，逐个遍历链表中的节点，直到找到目标节点或到达链表尾部。

2. 更新指针：

   一旦找到了需要删除的节点，需要更新链表中相邻节点的指针，以保持链表的连续性。通常情况下，需要修改前一个节点的指针，将其指向被删除节点的下一个节点，同时释放被删除节点的内存空间。

3. 释放内存：

   在更新指针后，需要释放被删除节点的内存空间，以防止内存泄漏。这一步是可选的，具体取决于编程语言和内存管理方式。

4. 处理特殊情况：

   在移除链表元素时，需要考虑一些特殊情况，比如链表为空、链表中只有一个节点、要删除的节点是头节点或尾节点等情况。

链表的定义方式，

1. 首先，定义了一个结构体ListNode，其中包含了一个整型成员变量val和一个指向ListNode类型的指针成员变量next。
2. 在结构体内部，通过构造函数ListNode(int x) : val(x), next(NULL) {}来初始化节点对象。构造函数接受一个整型参数x，用来初始化节点的val成员变量，同时将next指针初始化为NULL，表示当前节点为链表的末尾节点。
3. 通过结构体定义的方式完成了单链表节点的定义，可以使用ListNode类型来声明单链表的节点对象。

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

NOTE：如果不定义构造函数， C++默认生成一个构造函数，但是这个构造函数不会初始化任何成员变量

通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

我们需要区分头节点 和 其他节点的移除流程，因为移除一个节点就是找到这个节点的前一个节点

                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;

前一个节点指向下下个节点，就移除了当前节点 ，然后delete 释放内存

但是头节点没有前一个节点，所以删除头节点的方法是将头节点指针向后移动一位，这样就移除了头节点

移除节点（不使用虚拟头节点）

#include <iostream>

// 定义链表节点结构
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 移除链表中特定值的节点，区分头节点和普通节点
ListNode* removeElements(ListNode* head, int val) {
    // 处理链表为空的情况
    if (head == nullptr) {
        return nullptr;
    }

    // 处理头节点是要删除的节点的情况
    while (head != nullptr && head->val == val) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }

    // 处理普通节点是要删除的节点的情况
    ListNode* curr = head;
    while (curr != nullptr && curr->next != nullptr) {
        if (curr->next->val == val) {
            ListNode* temp = curr->next;
            curr->next = curr->next->next;
            delete temp;
        } else {
            curr = curr->next;
        }
    }

    return head;
}

 但是如上代码，就必须要把头节点和其他类型节点的移除分开来考虑，如果使用虚拟头节点，就不需要区分头节点和其他节点移除的情况！

虚拟头节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 创建一个虚拟头节点，其值为0
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        // 将虚拟头节点指向原链表的头节点，方便后面做删除操作
        dummyHead->next = head; 
        
        // 使用指针 cur 遍历链表，判断当前节点的下一个节点是否为要删除的节点
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            // 若当前节点的下一个节点值等于目标值 val，执行删除操作
            if(cur->next->val == val) {
                // 用临时指针 tmp 指向当前节点的下一个节点，以便后续释放内存
                ListNode* tmp = cur->next;
                // 将当前节点的 next 指针指向下一个节点的 next 指针，即跳过了下一个节点
                cur->next = cur->next->next;
                // 释放被删除节点的内存
                delete tmp;
            } else {
                // 若当前节点的下一个节点值不等于目标值 val，则继续遍历下一个节点
                cur = cur->next;
            }
        }
        
        // 将头节点指向虚拟头节点的下一个节点，即原链表的头节点，得到删除指定元素后的新链表
        head = dummyHead->next;
        // 释放虚拟头节点的内存空间，避免内存泄漏
        delete dummyHead;
        
        // 返回新链表的头节点
        return head;
    }
};

参考文章：代码随想录 (programmercarl.com)