一、203. 移除链表元素

链表

一、203. 移除链表元素

题解参考：代码随想录 (programmercarl.com)

原题链接：203. 移除链表元素 - 力扣（LeetCode）

1. 题目描述

给你一个链表的头节点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

2. 思路

大致有两种思路

• 思路一：直接在原链表删除，需要考虑头结点的值等于val的情况
• 思路二：新增一个虚拟头结点，使所有结点的删除规则一致

3. 原链表删除

这里以链表1->4->3->4为例，移出元素4：

如果使用C，C++编程语言的话，不要忘了还要从内存中删除这两个移除的节点， 清理节点内存之后如图：

当然如果使用java ，python的话就不用手动管理内存了。它们会有自己的内存回收机制。

这里有一点需要注意：移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。

所以头结点如何移除呢，其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点，如下图所示

记得把头结点从内存中删除，如下图所示

代码如下所示

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 * 时间复杂度：O(1)
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    // 临时结点,用于删除
    struct ListNode* temp;
    // 当头结点不为空且头结点的值不等于val，注意新的头结点也可能相等 
    while (head && head->val == val) {
        temp = head;
        head = head->next;
        // 释放结点空间
        free(temp);
    }
    // 当前指向的结点
    struct ListNode* cur = head;
    // 这里设置temp = cur->next,方便释放被删除结点的空间
    while (cur && (temp = cur->next) ) {
        // 如果cur->next的值等于val
        if (temp->val == val) {
            // 将cur->next设置为cur->next->next并删除cur->next
            cur->next = temp->next;
            free(temp);
        }
        else {
            // 没找到，指向下一个结点
            cur = cur->next;
        }
    }
    // 返回头结点
    return head;
}

• 时间复杂度：O(1)
• 注意：这里可能会出现多个结点数值一样，例：7->7->7->7，要删除7,这种情况下，头结点刚好等于要删除的值，且后面的结点的数值刚好也等于7，因此我们在设计删除头结点那段逻辑的时候要使用while，而不是if。

4. 虚拟头结点

从上面的例子可以看出，在单链表中删除头结点和其他结点的方式不一样，这个时候代码中需要单独写一段逻辑来处理移除头结点的情况。

那么我们可不可以用一种统一的逻辑来移除单链表的节点呢？

其实我们可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。

来看看如何设置一个虚拟头。依然还是在上面的链表中，移除元素1，如下图所示

这里我们给链表添加一个虚拟头结点dummyNode为新的头结点，如果我们要移除这个旧头结点元素1，就和删除其他结点的方式一样了。这样的话，我们在代码中就不需要单独写一段逻辑来处理头结点的情况了。

最后呢在题目中，return 头结点的时候，别忘了 return dummyNode->next;， 这才是新的头结点。

代码如下所示

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 * 时间复杂度：O(1)
 * 虚拟结点法
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    // 起别名
    typedef struct ListNode ListNode; 
    // 虚拟头结点
    ListNode* dummyHead = (ListNode *)malloc(sizeof(ListNode));
    dummyHead->next = head; 
    // 当前指向的结点
    ListNode* cur = dummyHead;
    while (cur->next) {
        // 如果cur->next的值等于val
        if (cur->next->val == val) {
            // 这里设置temp = cur->next,方便释放被删除结点的空间
            ListNode* temp = cur->next; 
            // 将cur->next设置为cur->next->next并删除cur->next
            cur->next = cur->next->next;
            free(temp);
        }
        else {
            // 没找到，指向下一个结点
            cur = cur->next;
        }
    }
    // 删除虚拟头结点
    head = dummyHead->next;
    free(dummyHead);
    // 返回头结点
    return head;
}

• 时间复杂度：O(1)

5. 总结

这道题如果在原链表上直接删除结点的话，还需要单独考虑头结点那段逻辑，比较繁琐。所以我们可以考虑设立一个虚拟头结点，为的就是使处理逻辑统一，方便代码的书写。

补充：链表和数组操作的时间复杂度对比

	插入/删除（时间复杂度）	查询（时间复杂度）	适用场景
数组	O(n)	O(1)	数据量固定，频繁查询，较少增删
链表	O(1)	O(n)	数据量不固定，频繁增删，较少查询

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。