链表删除指定元素异常：仅删除单个匹配项而非全部匹配项

你的代码存在两个核心问题导致无法删除所有匹配元素：

1. 头部处理的空指针风险+逻辑漏洞：当所有元素都是目标值时，head最终会变为NULL，此时访问head->val会直接崩溃；另外若头部之后还有连续目标值，原逻辑虽做了处理，但未考虑处理后头部为空的边界情况。
2. 中间元素遍历逻辑错误：循环条件curr->next != NULL会跳过最后一个节点的检查；且删除节点后curr直接移动到下一个节点，导致连续匹配的元素（比如两个3）会被跳过——删除第一个3后，prev->next已指向第二个3，但curr已经跳到5，没机会检查第二个3。

推荐使用虚拟头节点的方式，统一处理头部和中间节点的删除逻辑，避免单独判断头部的麻烦，同时保证遍历所有节点：

#include <iostream>
using namespace std; 

class Node {
public :
    int val;
    Node* next;

    Node(int data) {
        this->val = data;
        this->next = NULL;
    }
};


void insertAtTail(Node* &tail, int data) {
    Node* temp = new Node(data);
    tail->next = temp;
    tail = temp;
}

void print (Node* head) {
    while(head != NULL) {
        cout << head->val << " ";
        head = head->next;
    }
    cout << endl;
}

Node* removeElement(Node* head, int val) {
    // 创建虚拟头节点，统一处理头部删除逻辑
    Node* dummy = new Node(0);
    dummy->next = head;
    Node* curr = dummy;

    // 遍历整个链表，直到curr的下一个节点为空
    while (curr->next != NULL) {
        if (curr->next->val == val) {
            // 保存要删除的节点，避免内存泄漏
            Node* temp = curr->next;
            curr->next = curr->next->next;
            delete temp; // 释放被删除节点的内存
        } else {
            // 只有当前节点的下一个不是目标值时，才移动curr
            curr = curr->next;
        }
    }

    // 新的头部是虚拟头节点的下一个
    Node* newHead = dummy->next;
    delete dummy; // 释放虚拟头节点
    return newHead;
}

int main () {
    Node* node1 = new Node(1);
    Node* head = node1;
    Node* tail = node1;

    insertAtTail(tail, 1);
    insertAtTail(tail, 1);
    insertAtTail(tail, 3);
    insertAtTail(tail, 3);
    insertAtTail(tail, 5);
    
    print(removeElement(head, 3));
}

• 虚拟头节点：避免单独处理头部节点的特殊情况，不管头部是否是目标值，都能统一用相同逻辑删除。
• 遍历逻辑：循环条件确保遍历到最后一个节点，删除节点时不移动curr，而是保持curr在当前位置，这样可以检查新的curr->next是否也是目标值，不会跳过连续的匹配元素。
• 内存释放：添加delete操作，避免内存泄漏，这是C++链表操作中容易忽略的细节。

如果不想用虚拟头节点，也可以修改原逻辑，注意处理头部为空的情况及遍历中间节点的逻辑：

Node* removeElement(Node* head, int val) {
    // 先处理头部所有匹配的节点
    while (head != NULL && head->val == val) {
        Node* temp = head;
        head = head->next;
        delete temp;
    }

    if (head == NULL) {
        return NULL;
    }

    Node* curr = head;
    while (curr->next != NULL) {
        if (curr->next->val == val) {
            Node* temp = curr->next;
            curr->next = curr->next->next;
            delete temp;
        } else {
            curr = curr->next;
        }
    }

    return head;
}

这个版本先处理头部的所有匹配节点，再遍历中间节点，删除时不移动curr，确保连续的匹配节点都能被处理。

内容的提问来源于stack exchange，提问作者Frozen_Blood