代码随想录算法训练营 Day3

        今天的题都比较基础，因为学校开学晚，讲的慢（其实是学校太菜了）。。。难道不是我自己菜吗？破防了。。。

现在数据结构才刚开两节课，今天就当提前预习了。

/**
 * 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) {
            ListNode* newhead = new ListNode();
//因为头节点也有可能被移除，
//所以设置虚拟头节点，这样就不用单独考虑头节点被删除的情况了
            newhead->next=head;
            ListNode* curr =newhead;
            while(curr->next){
                if(curr->next->val==val){
                    ListNode *temp =curr->next;
                    curr->next=curr->next->next;
                    delete temp;
                }else{
                    curr=curr->next;
                }
            }
            
            return newhead->next;
    }
};

下面再附以下卡哥的代码，卡哥的代码最终是重新给头节点赋值的，这样就可以把虚拟头节点释放掉了。

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;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

既然是练习，那我们就再写一下不用虚拟头节点的代码吧（反正改不了几行，bushi

/**
 * 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) {
            while(head!=NULL&&head->val==val){
                head=head->next;
            }
            ListNode* curr=head;
           
            while(curr&&curr->next){
                if(curr->next->val==val){
                    ListNode *temp =curr->next;
                    curr->next=curr->next->next;
                    delete temp;
                }else{
                    curr=curr->next;
                }
            }
            
            return head;
    }
};

写一个小递归，把大象装冰箱一共分三步，那反转一个链表要分几步呢。

第一步，把头节点(之后称为1号节点）之后的所有结点都反转完。

第二步，把二号节点的后继指向一号节点

第三步，把一号节点的后继设置为NULL

什么？你问我一号节点之后的所有节点怎么反转？那就是从前有座山，山上有座庙的故事了。

/**
 * 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* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL){
                return head;
        }
            ListNode* newhead=reverseList(head->next);
            head->next->next=head;
            head->next=NULL;
            return newhead;

    }
};

偷个懒，现在不早了。设计链表就没有做，假期补上