数据结构与算法---线性表---删除链表中的节点、移除链表元素

237. 删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1：
输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2：
输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

提示：
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。

---

删除节点有两种方式：

方法一：

找到需要删除的节点（1）的前一个节点（5），将前一个节点的next指针，指向9节点；

如果找不到其前一个节点，怎么删除当前节点？
就比如要做的这道题，只给出了当前节点

void deleteNode(struct ListNode* node) {}

只给出一个当前节点，是没法找到其前一个节点的，因此，方法一在该题中不合适。

方法二：

将当前节点（1）的值，修改为当前节点的下一个节点（9）的值；
将当前节点（1）的next，修改为当前节点的下一个节点（9）的next；

这样，当前节点就变为了下一个节点的内容。其实是删除了9节点，效果看上去是删除了1节点。

方法二的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

void deleteNode(struct ListNode* node) {
    struct ListNode * nextNode = node->next;
    node->val = nextNode->val;
    node->next = nextNode->next;
}

新建的节点可以去掉，优化空间，优化后的代码：

void deleteNode(struct ListNode* node) {
    node->val = node->next->val;
    node->next = node->next->next;
}

Java版本：

class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

---

203. 移除链表元素

删除链表中等于给定值 val 的所有节点。

示例:
输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

---

思路：

上一题中，只能使用方法二去删除某一节点，这道题中，由于给的有头结点，因此，我们也可以使用方法一来解决问题。

循环遍历链表，找到所有值等于val的节点，并将其删除。

自己想出来的解题方法：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    if(head == NULL) return head;

    struct ListNode* pHead = head;
    while(pHead != NULL)
    {
        if(pHead->val == val)
        {
            if(pHead->next != NULL)
            {//值相等，且则按上面的方法二，删除当前节点
                pHead->val = pHead->next->val;
                pHead->next = pHead->next->next;
            }else{//值相等，且是尾节点的值，需要删除尾节点
                /**
                	pHead = NULL;
                	这个不对，pHead = NULL;将pHead本身的next值赋值为NULL，然而，前一个节点的next值还是没有改变

                	free(pHead);
                	这个也不对，free(pHead);会将节点内存释放，然而，前一个节点的地址还指向着这块内存空间，造成野指针错误。
                */
            }
        }else{
            pHead = pHead->next;
        }
    }
    return head;
}

该解法可以适用于：首结点有val，中间节点有val的链表。
但是，该解法不能用于：尾结点的val等于val的情况。

为何方法二删除当前节点不适用于尾结点？

画图分析：

假如我们有一个链表，链表元素有[1, 6]，现在要删除节点6

struct ListNode* pHead = head;代码的效果：

由于第一个结点的值等于1，与需要比较的值6不相等，因此，执行pHead = pHead->next;
代码的效果：

pHead != NULL成立，进入while循环
pHead->val == val成立

pHead->next等价于(*pHead).next，节点6的next值，等于NULL
也就是，pHead指向的只有一个节点，也就是尾结点的val等于val的情况

自己做题的时候想出了两种方法：

方法一：

pHead = NULL;

首先，看下pHead = NULL;

pHead == NULL，是将pHead自己的next指针赋值为NULL，而尾结点6只是没有了pHead的指针引用，而节点1对节点6的引用还是存在的。也就是6没有从链表中删除。

方法二：

free(pHead);

通过使用free(pHead)操作，可以将6的节点从内存中释放。
但，问题是，节点1的next存储的值还是0x003，虽然0x003的内存已经被释放。这就造成了悬垂指针的错误。

总结

想出的两种删除尾结点的方法都不对，翻看《剑指OFFER》，发现上面有这些内容：

---

算法改进：

使用方法一，找出需要删除节点的前一个节点

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head == NULL) return head;

    struct ListNode* preNode = head;//当前节点的前一个节点
    struct ListNode* currentNode = head;//当前节点

    while(currentNode != NULL)
    {
        if(currentNode->val == val)
        {
            if(currentNode->next != NULL){
                preNode->next = preNode->next->next;
            }else{
                preNode->next = NULL;
            }
        }else{
            preNode = currentNode;
        }

        currentNode = currentNode->next;
    }
    return head;
}

该算法适用于，需要删除的数据在链表中间、尾部
不适用于值在头部

为了适用于头结点的值为所需要的值，可以添加一个while循环：

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head == NULL) return head;

    while(head->val == val)
    {
        if(head->next != NULL){
            head = head->next;
        }else{
            return NULL;
        }
    }
    struct ListNode* preNode = head;//当前节点的前一个节点
    struct ListNode* currentNode = head;//当前节点

    while(currentNode != NULL)
    {
        if(currentNode->val == val)
        {
            if(currentNode->next != NULL){
                preNode->next = preNode->next->next;
            }else{
                preNode->next = NULL;
            }
        }else{
            preNode = currentNode;
        }

        currentNode = currentNode->next;
    }
    return head;
}

至此，该算法题算是可以解决了。

关于

while(head->val == val)
{
        if(head->next != NULL){
            head = head->next;
        }else{
            return NULL;
        }
}

可以优化为：

while(head != NULL && head->val == val)
{
	head = head->next;
}

但，不可以写成：

while(head->val == val)
{
	head = head->next;
}
或者
while(head->val == val && head != NULL)
{
	head = head->next;
}

假如，该链表只有一个节点，节点的val=6，需要删除的值也是6。因为只有一个节点，那么节点的next = NULL;
那么，第一个while成立，head = head->next，那么head = NULL
再循环，使用NULL->val == val，就错误了。
同理，第二个while也不对。

最终的做法：

使用头结点

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head == NULL) return NULL;//可以省略

    //建立虚拟节点(头结点)
    struct ListNode* headNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    headNode->val = -1;
    headNode->next = head;

    struct ListNode *preNode = headNode;
    while(preNode->next != NULL)
    {
        if(preNode->next->val == val){
            preNode->next = preNode->next->next;
        }else{
            preNode = preNode->next;
        }
    }
    return headNode->next;
}

递归方法

struct ListNode* removeElements(struct ListNode* head, int val){
    //递归
    if(head == NULL) return NULL;
    head->next = removeElements(head->next, val);
    return head->val == val ? head->next : head;
}

不需要判断head->next是否为NULL
如果head->next == NULL，则removeElements(head->next, val);为removeElements(NULL, val);，返回的是NULL
head->next = NULL;也没事

小知识点：

head == NULL，则链表为空，一个节点也没有
head != NULL，则链表不为空，至少有一个节点
head->next == NULL，则链表不为空，只有一个节点
head->next != NULL，则链表不为空，至少有两个节点