力扣学习day8

1.学习目标

1.按照如下类型来刷题：数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。
2.动手用多种语言来进行写题，并要有自己的代码模板。
3.总结程序员简历技巧。

学习网址

---

2.链表

203. 移除链表元素

2.1 题目

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

链表的常规入门题目，思路十分的简单，具体实现的时候还是有很多值得注意的地方，为此我要进行总结。

2.2 虚拟头节点

用一个虚拟结点指向头节点，可以少考虑很多情况，例如删除头结点，其它的步骤和正常的删除节点是一样的。

(1)C++版本

下面是对使用虚拟头节点和不使用头节点的区别：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点 
        while (head != NULL && head->val == val) { // 注意这里不是if
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头结点
        ListNode* cur = head;
        while (cur != NULL && cur->next!= NULL) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;

        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return dummyHead->next;
    }
};

（2）C语言版本

C语言指针的使用和内存申请和释放感觉都遗忘了，调试了半天才跑通，真不愧是我。

因为使用了虚拟头节点，所以内存消耗有点大（为啥8M,想不明白咋这么大），不过这个代码显然是可以优化的，为了方便起见我使用了三个指针，一个指向开头用于返回，两个用于遍历和删除节点，但实际上两个指针就够了，纯属个人懒。

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


struct ListNode* removeElements(struct ListNode* head, int val){
if(head==NULL)
return NULL;
struct ListNode *pre=(struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode *cur=head;
struct ListNode *p;
pre->next=head;
p=pre;
while(cur!=NULL)
{
    if(cur->val==val)
        {
            pre->next=cur->next;
            free(cur);
            cur=pre->next;
        }
    else
    {
        pre=cur;
        cur=cur->next;
    }
}
return p->next;
}

2.3 递归法

这个是我看到一个大佬写的算法，链接在这。

算法如下：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
       if(head==null)
           return null;
        head.next=removeElements(head.next,val);
        if(head.val==val){
            return head.next;
        }else{
            return head;
        }
    }
}

我递归学的不是很好，脑海里有个疑问，该算法会不会导致栈溢出，因为我记的递归不同的写法，一个会导致栈的层数不断叠加，最终会因为深度而溢出。而另一种写法则是引用相同的地址，不会导致栈溢出。争对这个问题，我之后还是得总结一下。

后面回忆起，有一种叫做尾递归的方法，可以避免栈溢出，但这需要编译器的优化，而大多数编程语言不会对其进行优化。我只能说递归少用一点最好，一旦这个给定的链表较大，直接可以内存爆炸的。

3.闲聊

今天暂时到这吧，晚上同学请客，吃了一顿大餐，回家还要听我妈念叨做人的道理，对象要怎么找，实在没什么心情写算法了。不过还好，明天我就可以一个人学习了，应该可以提高速度。