203.移除链表元素

题目链接：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, 104] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

1、不带头结点

代码

/**
 * 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) {}
 * };
 */
// 定义一个名为Solution的类  
class Solution {  
public:  
    ListNode* removeElements(ListNode* head, int val) { 
        // 当头结点存在并且头结点的值等于val时 
        while (head != nullptr && head->val == val) { // 注意这里不是if  
            // 声明一个临时变量tmp来保存头结点的地址  
            ListNode* tmp = head;  
            // 将头结点指向下一个节点，即删除头结点  
            head = head->next;  
            // 删除临时变量tmp所指向的头结点，即释放头结点所占用的内存空间  
            delete tmp; 
            tmp = nullptr; 
        }  
  
        ListNode* curr = head;  
        // 当前节点不为空且其下一个节点不为空时，执行循环
        while (curr != nullptr && curr->next != nullptr) {  
            // 如果当前节点的下一个节点的值等于要删除的值val
            if (curr->next->val == val) {  
                // 声明一个临时变量tmp来保存下一个节点的地址  
                ListNode* tmp = curr->next;  
                // 将当前节点的下一个节点指向下一个节点的下一个节点，即删除下一个节点  
                curr->next = curr->next->next;  
                // 删除临时变量tmp所指向的节点，即释放该节点所占用的内存空间  
                delete tmp;
                tmp = nullptr;
            } else {  
                // 如果当前节点的下一个节点的值不等于要删除的值val，则移动curr指针到下一个节点  
                curr = curr->next;  
            }  
        }  
        // 返回处理过的链表的头结点  
        return head;  
    }  
};

复杂度分析  

• 时间复杂度: O(n)
• 空间复杂度: O(1)

2、带虚拟头结点

代码

/**
 * 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) {
        // 如果链表为空，直接返回空指针  
        if (!head) {  
            return nullptr;  
        }  
  
        // 创建一个虚拟头节点，值为0，next指向原链表的头节点  
        ListNode* dummyHead = new ListNode(0);   
        dummyHead->next = head;   
        // 定义一个指针curr，初始指向虚拟头节点，便于后续操作  
        ListNode* curr = dummyHead;   
  
        // 遍历链表，直到curr->next为空为止  
        while (curr->next != nullptr) {  
            // 如果当前节点的值等于要删除的值val，则进行删除操作  
            if (curr->next->val == val) {  
                // 临时保存当前要删除的节点  
                ListNode* tmp = curr->next;   
                // 将curr的next指向当前要删除节点的下一个节点，实现删除操作  
                curr->next = curr->next->next;   
                // 释放被删除节点的内存空间  
                delete tmp;   
            } else {  
                // 如果当前节点的值不等于要删除的值val，则将curr指针移动到下一个节点  
                curr = curr->next;   
            }  
        }  
        // 返回虚拟头节点的下一个节点作为新的链表头节点，并释放虚拟头节点的内存空间  
        head = dummyHead->next;   
        delete dummyHead;   
        return head;   
    }  
};

复杂度分析  

• 时间复杂度: O(n)
• 空间复杂度: O(1)