力扣203. 移除链表元素

题目来源（力扣）：

https://leetcode.cn/problems/remove-linked-list-elements/description/

题目描述：

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

基本思路：

删除值为val的数，即可能有多次删除，甚至删除完毕后可能变为空链表。
因此，常用虚拟头结点，使得操作变得简洁统一

参考《代码随想录》中的写法，如下：

代码实现：

/*
//节点定义
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 *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *pre, *p;
        pre = dummyHead;
        p = head;
        while (p)
        {
            if (p->val == val)
            {
                pre->next = p->next;
                p = p->next;
            }
            else
            {
                pre = p;
                p = p->next;
            }
        }
        return dummyHead->next;
    }
};

注意到以上代码虽然完成了基本需求，但是没有对删除的节点进行delete 操作
因此，利用tmp临时保存，然后利用delete完成内存资源的释放

class Solution
{
public:
    ListNode *removeElements(ListNode *head, int val)
    {
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *pre, *p, *tmp;
        pre = dummyHead;
        p = head;
        while (p)
        {
            if (p->val == val)
            {
                tmp = p;
                pre->next = p->next;
                p = p->next;
                delete tmp;
            }
            else
            {
                pre = p;
                p = p->next;
            }
        }
        return dummyHead->next;
    }
};

在《代码随想录》中，更加巧妙地隐藏了变量p，只保留了pre，更加简洁，代码如下:

class Solution
{
public:
    ListNode *removeElements(ListNode *head, int val)
    {
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *pre, *tmp;
        pre = dummyHead;
        while (pre->next)
        {
            if (pre->next->val == val)
            {
                tmp = pre->next;
                pre->next = pre->next->next;
                delete tmp;
            }
            else
            {
                pre = pre->next;
            }
        }
        return dummyHead->next;
    }
};

时间复杂度

O(n)，n为链表长度