203.移出链表元素（4种思路）

题目：

把一条链中某个值删除

递归：

涉及链表的题一般可以想到的方法就是递归法，设计一个函数，然后确定一个值，重复的遍历整个链表当链表的某个值与给定的值相同时则删除。

代码段：

/**
 * 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;
    }
然后就是进行不断的递的过程，一个一个结点在递的过程中挂在一起。
    head->next=removeElements(head->next,val);
//最后的条件就是考验的对局部问题的分析，假设我们归回来到一个第一个结点了，我们是不是就是要对这个结点进行判断，看他里面的值是不是和val值相同，如果相同的话我们返回的头结点就是第一个结点的后一个结点。
    if(head->val==val){
        return head->next;
//否则就是返回这个结点。
    }else{
        return head;
    }
//有一部分童鞋会习惯性的再在这里再来一个return，做总结。（其实也是自己犯过的原因）要想啊之前上一步都return过了呀，所以这里就不需要了
}

双指针

我们需要设置两个结点一个前驱结点和一个后继结点。所以我们只要声明一个node变量来记录要删除的结点的前驱节点。用pre来标记前驱结点，cur来标记需要被删除的结点，pre初始化为head，cur初始化为head.next。当cur.next！=null时，表示链表还没遍历完，当成立时表示链表遍历完了。遍历过程中，我们只需要关注cur结点的val。当cur.val=给定的val时，表示需要删除当前cur结点，所以cur=cur.next，pre.next=cur。当不等于时需要将pre和cur结点都向后移动，即pre=cur，cur=cur.next；这样遍历完后。除了head结点没有判断外，其余结点已经都遍历完了。最后就只要判断head.val是否等于给定的val，等于则head=head.next。

代码段：

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


struct ListNode* removeElements(struct ListNode* head, int val){
//首先对头结点进行判断
    while(NULL!=head&&head->val==val){
        head=head->next;
    }
    struct ListNode* cur=head;
    struct ListNode* pre=head;
//设置两个结点，一个在前一个在后，在前面的cur主要是用来判断和val值比较。在后面的负责把链表挂起来
    while(cur!=NULL){
        if(cur->val==val){
            pre->next=cur->next;
        }else{
            pre=cur;
        }
        cur=cur->next;
    }
    return head;
}

哑结点：
在很多方法里都要对这个链表的头结点进行判断，看这个头结点的值等不等于val，所以就要考虑头结点的位置问题。但添加了哑结点后就不需要考虑那么多，让哑结点充当头结点。起到固定头结点位置的作用。

代码段：

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


struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* dummy=malloc(sizeof(struct ListNode));
//其实这里还应该添加一个if（dummy==NULL）的判定，因为有时候空间会申请不成功。但不加也没那么大的问题。
    dummy->next=head;
    struct ListNode* node=dummy;
//遍历判断的过程
    while(node->next!=NULL){
        if(node->next->val==val){
            node->next=node->next->next;
        }else{
            node=node->next;
        }
    }
//设置一个结点来存储头结点
    struct ListNode* retnode=dummy->next;
//c或者c++语言中申请了内存一定要记得释放。
    free(dummy);
    return retnode;
}

迭代：

思路其实和双指针大同小异，双指针的意义在于一个在前面跑，探路，一个在后面确保挂链。但单指针就是形容可能会更谨慎一些，它遍历到的地方对下一个结点值进行判定，确保可以正常挂链。

代码段：

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


struct ListNode* removeElements(struct ListNode* head, int val){
    while(head!=NULL&&head->val==val){
        head=head->next;
    }
//上面对头结点的判定，下面我们就要考虑一个问题，万一在上面一个循环内把所有的结点全删了，那么这个链表就变成NULL了，所以我们要进行判空操作。
    if(head==NULL){
        return head;
    }
    struct ListNode* pre=head;
    while(pre->next!=NULL){
        if(pre->next->val==val){
            pre->next=pre->next->next;
        }else{
            pre=pre->next;
        }
    }
    return head;
}