【数据结构题目】移除链表元素的三种方法（层层递进）

1.题干

2.解题方法

2.1 方法一：双指针法

顾名思义，双指针法就是同时运用两个指针的方法

2.1.1 完整代码

struct ListNode* removeElements(struct ListNode* head, int val) 
{
    //如果头节点的值为val，则将其后继节点更新为新的头节点
    while (head != NULL && head->val == val)
    {
        struct ListNode* temp = head;//创建临时指针
        head = head->next;//将其后机节点更新为新的头节点
        
        //回收动态内存空间
        free(temp);
        temp == NULL;
    }
	
	//创建两个指针
    struct ListNode* pcur = head;
    struct ListNode* pre = head;

    while (pcur)//当pcur为NULL时，退出循环
    {
        if (pcur->val == val)
        {
            //删除值为val的节点
            struct ListNode* temp = pcur;
            pre->next = pcur->next;
            free(pcur);
            //后移pcur指针
            pcur = pre->next;
        }
        else
        {
            //不删除，后移pre指针
            pre = pcur;
            //后移pcur指针
            pcur = pcur->next;
        }
    }
    return head;
}

2.1.2 复杂度分析

时间复杂度
1) 处理头节点：在最坏的情况下，可能需要遍历所有头节点直到找到第一个值不为val的节点。这一步的时间复杂度为O(n)，其中n为链表的长度。
2) 遍历链表：在循环中，pcur指针从头节点开始遍历整个链表。每次循环，pcur指针最多移动一次，直到链表结束。因此，这一步的时间复杂度也是O(n)。
由于这两步操作是连续的，所以总的时间复杂度为O(n)。

空间复杂度O(1)

2.1.3 提醒

1) 如果头结点就是val,则直接使第二个结点成为新的头结点。
2) 如果找到了val，pre指针不需要后移，只需要执行删除操作然后使pcur后移。
3) pre可以为NULL，因为经过第一个while循环的head筛选后，头结点不可能为val，所以第一次while循环绝对会执行pre=pcur的操作，后续就可以正常执行pre->next的操作。

2.2 方法二：定义新链表

遍历原链表不为val的节点，尾插在新链表中，返回新链表

2.2.1 完整代码

typedef struct ListNode ListNode;

struct ListNode* removeElements(struct ListNode* head, int val) 
{
    //定义新链表
    ListNode* newHead = NULL;
    ListNode* newTail = NULL;
	
	//创建临时指针
	//虽然其实因为传值调用，无法在其函数内部修改真正head的值，但是还是要养成好习惯
    ListNode* pcur = head;

    //遍历链表
    while (pcur)
    {
        //pcur值不为val，就尾插到新链表后再后移
        if (pcur->val != val)
        {
            if (newHead == NULL)
            {
                //链表为空，新链表的头尾节点都是pcur
                newHead = newTail = pcur;
            } 
            else
            {
                //链表不为空，尾插后只更新尾节点
                //尾插
                newTail->next = pcur;
                //更新尾节点
                newTail = pcur;
            }
        }

        //pcur值为val,就直接后移
        pcur = pcur->next;//注意：pcur的后移是一直在进行的，不是只有值为val才后移
    }

    //特殊情况：当原链表尾节点的值为val时，经过上面while循环，
    //倒数第二个节点插入新链表后，其仍指向原链表尾节点， 
    //所以需要将新链表的尾节点的后继节点置为空
    //还有一个前提是newTail不能为空，否则无法取到其后继节点，会报错
    if (newTail)
    {
        newTail->next = NULL;
    }
    
    return newHead;
}

2.2.2 复杂度分析

时间复杂度
while循环会遍历链表中的每一个节点，直到pcur为NULL。因此，时间复杂度为O(n)，其中n是链表的长度。
空间复杂度
由于创建了一个新的链表来存储不等于val的元素，最坏情况下，链表中没有元素需要移除，此时新链表的长度与原链表相同，空间复杂度为O(n)。

2.3 方法三：递归

2.3.1 递归的概念以及在本题的运用

递归算法是一种在解决问题时自我引用的计算方法。它通过将问题分解为更小的、相似的子问题（解决方法和大问题一致）来解决问题，直到这些子问题变得足够简单，可以直接解决。
而本题的解决方法就是“如果头节点的值为val,就删除头节点”，因为每个节点都可以当做它后继所有节点的头节点，所以可以用递归的思想，把每个节点都当作头节点来处理一遍，简化代码。
res的作用是存储递归调用返回的结果，这个结果代表了从头节点的下一个节点开始，删除所有值为 val 的节点之后得到的新链表的头节点。

2.3.2 完整代码

struct ListNode* removeElements(struct ListNode* head, int val)
{ 
   if (NULL == head)//如果递推到了最后一个节点，则开始回归
   {
       return head;
   }     

   struct ListNode* res = removeElements(head->next, val);
   //res用来存储被删除的节点的后继节点

   //如果当前头节点的值为val，则返回头节点的后继节点，就实现了删除头节点的操作
   if (head->val == val) 
   {
       free(head);//释放当前头节点内存
       return res;
   } 
   else//如果当前头节点不为val，则使当前头节点指向被删除的节点的后继节点
   {
       head->next = res;
       return head;//返回当前的头节点
   }
}

2.3.3 图解

2.3.4 复杂度分析

时间复杂度
递归函数removeElements对每个节点调用一次，直到链表的末尾。因此，时间复杂度是O(n)，其中n是链表的长度。
空间复杂度
递归方法的空间复杂度主要取决于递归调用栈的深度。在最坏的情况下，即链表中所有节点的值都为val或链表中没有节点需要移除，递归调用栈的深度为链表的长度。因此，空间复杂度为O(n)。

2.3.4 总结与提醒

1) res 指向了删除当前 head 节点之后链表的剩余部分。 如果 head 节点是待删除的节点（即 head->val == val），则 head 节点将被释放，res 将成为新的头节点，指向的就是经过删除操作后的链表的头节点。
2) 如果 head 节点不是待删除的节点，head->next 将被设置为 res，从而将当前的 head 节点连接到经过删除操作后的链表上。
3) 在递归的底部，当 head 为 NULL 时，res 将保持为 NULL，这表示已经到达了链表的末尾。