(重点)Remove Linked List Elements和Delete Node in a Linked List

注意，这两种删除，其实被删除的结点都还在，只是从头结点开始的不断的链条看起来是删除之后的样子，而这个链条上还挂着没删掉的小链子的。就是说被删除结点的下一个结点，删除之后是有两个结点指向它的，一个是主链条上的结点，一个是‘删除’了的结点。leetcode可能不管，但是觉得在用的时候要把这个结点delete掉。

1->2->8->6->5  

 删除掉2：1->8->6->5

                          ^

                          |

                         2

(凑合看吧不知道怎么编辑，就是2就是那个出来小链子，没delete，所以2还是指向8的)

删掉1：1->2->8->6->5   你可能会问我这不是没删吗，删了的原因是我现在返回的新的指向头结点的指针是指向2的，不是指向1，所以这样看就删掉了。下面的解法头结点就是这么处理的，把head改了，但是1还是有的，它的next还是指向2的。

能突出体现的就是这两种解法关于头结点的是另一道题，Delete Node in a Linked List：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        //ListNode **cur=&node;
        //*cur=(*cur)->next;
        *node=*(node->next);
    }
};

注释里按照前一道题的删除不对的原因就是头结点相当于没删除.....然后办法就是直接把指针指向的结点改了......

前一道题解法：

删除操作，**是可以不考虑head的特殊情况的：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode **cur=&head;              //如果又想不明白了，就算地址，就是把每个指针是谁的地址列出来，就能整明白这个**了。  
        while((*cur)!=NULL)   
        {
            if((*cur)->val==val)
            {
                (*cur)=(*cur)->next;     //如果删头结点，cur存了head的地址，*cur就是head，现在把*cur改了，就是把head的内容改了，还是叫head，但head的内容变了，变成了第二个结点的指针。
            }                            //其余结点以此类推，就是把指向这个结点的指针用另一个指针指着（另一个指针存着指向结点指针的地址），然后通过这个指针改掉指向结点的指针的内容，就达到了删除结点的效果。
            else
            {
                cur=&((*cur)->next);
            }
        }
        return head;
    }
};

自己编的考虑特殊情况只用*的·：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *cur=head;
        while(cur!=NULL&&cur->val==val)
        {
            head=cur->next;
            cur=cur->next;
        }
        while(cur!=NULL&&cur->next!=NULL)
        {
            if(cur->next->val==val)
            {
                cur->next=cur->next->next;
            }
            else
            {
                cur=cur->next;
            }
        }
        return head;
    }
};

递归·：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==NULL)
        {
            return NULL;
        }
        head->next=removeElements(head->next,val);
        return head->val==val?head->next:head;
       
    }
};