LeetCode 刷题 203-CSDN博客

文章介绍了两种不同的C++方法来删除链表中所有值等于给定值的节点。第一种方法直接在原链表上操作，第二种方法利用虚拟头节点简化头节点处理。两种方案都关注了删除节点后的内存管理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一次做链表题

自己的思路与写法明显的复杂化了，太多不必要的步骤

先找到第一个不等于目标元素的节点作为头节点

定义一个指针h 指向当前可行链表的最后一个元素，再定义一个指针cnt进行遍历链表

cnt遍历到目标时，h连接至cnt， h=cnt， cnt = cnt->next，继续遍历。否则继续cnt=cnt->next

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 先找出第一个值不等于val的节点作为头节点
        if (head != nullptr)
        {
            while (head->val == val)
            {   
                if (head->next != nullptr)
                    head = head->next;
                else
                    return nullptr;
            }
        }
        else
            return nullptr;

        ListNode *h = head;
        ListNode *cnt = h->next;
        
        while (h != nullptr)
        {

            if (cnt == nullptr)
                break;

            while (cnt->val == val)
            {
                ListNode *de = cnt;
                cnt = cnt->next;
                delete de;
                if (cnt == nullptr)
                    break;
            }  

            h->next = cnt;
            h = cnt;

            if (cnt != nullptr)
                cnt = cnt->next;
        }
        
        return head;
    }
};

学习别人的做法

C++删除节点后，记得清理节点内存

使用原链表进行删除操作

使用虚拟头节点进行删除操作

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头节点
        while (head != nullptr && head->val == val)
        {
            ListNode *de = head;
            head = head->next;
            delete de;
        }

        ListNode *cnt = head;

        while (cnt != nullptr && cnt->next != nullptr)
        {
            if (cnt->next->val == val)
            {
                ListNode *de = cnt->next;
                cnt->next = cnt->next->next;
                delete de;
            }
            else
                cnt = cnt->next;
        }
        return head;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头节点
        ListNode *dummy = new ListNode(0, head);
        ListNode *cnt = dummy;

        while (cnt != nullptr && cnt->next != nullptr)
        {
            if (cnt->next->val == val)
            {
                ListNode *de = cnt->next;
                cnt->next = cnt->next->next;
                delete de;
            }
            else
                cnt = cnt->next;
        }
        head = dummy->next;
        delete dummy;
        return head;
    }
};

好处是头节点的处理方式和其他节点一致