203_移除链表元素

记录一个菜鸡小白的刷题过程。 

题目：

给你一个链表的头节点 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
输出：[]

感觉是个很简单的题目。

删除对应的链表就好了

---

第一次尝试

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *p=new ListNode;
        ListNode *p1=new ListNode;
        p=head;
        while(p->val==val&&p->next!=NULL){//头结点
            p1=p;
            p=p->next;
            head=p;//重新设置头结点
            delete p1;//删除原来头结点
           
        }
        while(p->next!=NULL){//若不是头结点
            if(p->next->val==val){
                p1=p->next;
                p->next=p1->next;//将下一个结点指向被删除结点的下一个结点
                delete p1;
                p=p->next;
            }
        }
        return head;
    }
};

不过它说我超出时间限制，我个菜鸡没看出来是自己写了死循环还是程序就是超时了。

---

看一下官方的答案对比一下： 

1.迭代法：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        struct ListNode* dummyHead = new ListNode(0, head);//创建在头结点前的结点？
        struct ListNode* temp = dummyHead;//创建结点等于它
        while (temp->next != NULL) {
            if (temp->next->val == val) {
                temp->next = temp->next->next;//在这里不用让temp=temp->next，因为已经将原有的next删掉了
            } else {
                temp = temp->next;//或者直接迭代
            }
        }
        return dummyHead->next;//返回头结点
    }
};

获得：

• 若不方便检查头结点是否符合条件，可创建一个在头结点之前的头结点，即虚拟头结点。在正式代码前给出了提示。
• 在查到符合条件的temp时不用往下迭代。
• 记得删除舍去的结点，delete p;

然后我自己加了个删结点的，区别不大

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
       ListNode *prohead=new ListNode(0,head);
       ListNode *p=new ListNode;
       ListNode *p1=new ListNode;
       p=prohead;
       while(p->next!=NULL){
           if(p->next->val==val){
               p1=p->next;
               p->next=p1->next;
               delete p1;
           }
           else 
                p=p->next;
       }
       return prohead->next;
    }
};

2.递归法：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if (head == nullptr) {//结束条件
            return head;
        }
        head->next = removeElements(head->next, val);//将递归延续到下一个结点
        return head->val == val ? head->next : head;//判断这个结点是否符合条件，符合则上一个结点的下一个结点确定就是这个，如果不对就跳过这个结点。
    }
};

这简洁的几行代码着实让我倾佩。

收获：

1. 关于nullptr与NULL的差别，都是空。NULL在函数重载的时候会出现二义性。多用nullptr。点击链接

确定为题规模，确定终止条件，确定递推情况，有递推式求出T（n），用复杂度表示T（n）

linkNode *remove(linkNode *head,int val){
    if(head->next=nullptr){//结束条件
        return head;
    }
    
    remove（head->next,val);//这个是用来进行到下一个，延续下去
    return head->val=val?head->next:head;//这个是用来判断这一个是否符合条件，不符合的话，上一个结点的下一个结点就是这个结点的下一个
}