LeetCode 203. 移除链表元素

蹊黎

已于 2024-05-01 23:55:59 修改

阅读量510

点赞数 17

分类专栏：双指针 LeetCode 文章标签： leetcode 链表算法

于 2024-04-28 23:37:36 首次发布

本文链接：https://blog.csdn.net/weixin_74385491/article/details/138292506

版权

LeetCode 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

双指针

14 篇文章 0 订阅

订阅专栏

1.原题链接：

203. 移除链表元素

2.双指针（无虚拟头结点）：

先定义两个指针：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val)
{
    ListNode* pre=NULL;
    ListNode* cur=head;
    return head;
}

遇到目标结点：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val)
{
    ListNode* pre=NULL;
    ListNode* cur=head;
    while(cur!=NULL)
    {
        if(cur->val==val)
        {
             pre->next=cur->next;
             free(cur);
             cur=pre->next;
        }
        else
        {
            // pre=pre->next;//不能这么写，因为会存在对空指针的访问，当最初pre为NULL时
            pre=cur;
            cur=cur->next;
        }
    }
    return head;
}

特殊情况：

所以，要做一下特殊处理：

这样就解决了上述问题（只需要在满足 cur->val==val 条件时，再加上一种情况）。

代码实现：

①.C语言版：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val)
{
    ListNode* pre=NULL;
    ListNode* cur=head;
    while(cur!=NULL)
    {
        if(cur->val==val)
        {
            if(cur==head)
            {
                head=cur->next;
                free(cur);
                cur=head;
            }
            else
            {
                pre->next=cur->next;
                free(cur);
                cur=pre->next;
            }
        }
        else
        {
            pre=cur;
            cur=cur->next;
        }
    }
    return head;
}

②.C++版：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) 
    {
        ListNode* pre=NULL;
        ListNode* cur=head;
        while(cur!=NULL)
        {
            if(cur->val==val)
            {
                if(cur==head)
                {
                    head=cur->next;
                    delete(cur);
                    cur=head;
                }
                else
                {
                    pre->next=cur->next;
                    delete(cur);
                    cur=pre->next;
                }
            }
            else
            {
                pre=cur;
                cur=cur->next;
            }
        }
        return head;
    }
};

3.哨兵（虚拟头结点）：

其实我们可以不这么麻烦，不就是多了一种头结点的值等于目标值的情况吗，那我们把这种情况去掉不就全是一般情况了吗。所以，我们可以使用虚拟头结点。

代码实现：

①.C语言版：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val)
{
    ListNode* newHead=(ListNode*)malloc(sizeof(ListNode));//创建一个虚拟头结点
    newHead->next=head;
    ListNode* pre=newHead;
    ListNode* cur=head;
    while(cur!=NULL)
    {
        if(cur->val==val)
        {
            pre->next=cur->next;
            free(cur);
            cur=pre->next;
        }
        else
        {
            pre=cur;
            cur=cur->next;
        }
    }
    return newHead->next;//不能返回head哦，有可能head这个结点已经被我们删掉了（当head->val==val）
}

②.C++版：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* newHead=new ListNode(0,head);//创建一个虚拟头结点
        ListNode* pre=newHead;
        ListNode* cur=head;
        while(cur!=nullptr)
        {
            if(cur->val==val)
            {
                pre->next=cur->next;
                delete(cur);
                cur=pre->next;
            }
            else
            {
                pre=cur;
                cur=cur->next;
            }
        }
        return newHead->next;//不能返回head哦，有可能head这个结点已经被我们删掉了（当head->val==val）
    }
};

其实这个题也可以用递归方法解决，但是我认为递归学习起来不是一朝一夕的事情，等后面开始写递归专题的时候再来补充吧。毕竟对于递归，我还需要沉淀沉淀。（其实能写迭代，尽量不写递归，一般当使用迭代很麻烦时才考虑递归，毕竟递归会比迭代更难理解些，在我看来）。