代码随想录算法训练营第三天| ● 链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

状态：1、203自己用的不加头结点的办法，讨论了删除head的特殊情况。

注意C++是new和delete配套，C才是malloc和free，别记混。

/**
 * 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* p=head;
        ListNode* pre=head;
        while(p!=nullptr)
        {
            if(p->val==val)
            {
                if(p==head)
                {
                    head=head->next;
                    delete p;
                    p=head;
                    pre=p;
                }
                else{
                    pre->next=p->next;
                delete p;
                p=pre->next;
                }
            }
            else{
                pre=p;
            p=p->next;
            }
        }
        return head;
    }
};

方法2：带头结点的链表可以统一操作，对空链表和非空链表、链表里面的各个元素都是统一的，不用讨论特殊情况，所以没有头结点就自己定义一个：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* p=head;
        ListNode* L=new ListNode(0,head);
        ListNode* pre=L;
        while(p!=nullptr)
        {
            if(p->val==val)
            {
                pre->next=p->next;
                delete p;
                p=pre->next;
                
            }
            else{
                pre=p;
                p=p->next;
            }
        }
        head=L->next;  //head可能delete，需要更新head指针
        delete L;
        return head;
    }
};

2、707设计链表。

自己写虽然逻辑很简单，但是还是出错了，主要是get和删除index下标的函数，(if p->next!=null)p可能是nullptr所以报错。

struct listNode{
        int val;
        struct listNode *next;
    };

class MyLinkedList {
public:
    listNode* head;
    MyLinkedList() {
        head=new listNode();
        head->next=nullptr;
    }
    
    int get(int index) {
        listNode *p=head;
        for(int i=-1;inext;
        }
        if(p==nullptr)return -1;
        return p->val;
    }
    
    void addAtHead(int val) {
        listNode* e=new listNode();
        e->val=val;
        e->next=head->next;
        head->next=e;
    }
    
    void addAtTail(int val) {
        listNode* p=head;
        while(p->next!=nullptr)
        {
            p=p->next;
        }
        listNode* e=new listNode();
        e->val=val;
        e->next=nullptr;
        p->next=e;
    }
    
    void addAtIndex(int index, int val) {
        listNode *p=head;
        int i=0;
        for(;inext!=nullptr;++i)
        {
            p=p->next;
        }
        if(ival=val;
        e->next=p->next;
        p->next=e;
    }
    
    void deleteAtIndex(int index) {
        listNode *p=head->next;
        listNode *pre=head;
        for(int i=0;inext;
        }
        if(p==nullptr)return ;
        pre->next=p->next;
        delete p;
    }

    
};

3、707设计链表。

2个点，1、下面的代码运行会报错heap-use-after-free，初始化改为p=head,pre=nullptr就不会错。

2、p不为空的时候，p到head是已经反转的部分，r到尾部是原来的一部分，p和r之间断开。到最后p为空，pre到head是反转完的整个链表。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr)
        {
            return nullptr;
        }
        ListNode *p=head->next;
        ListNode *pre=head;
        ListNode *r=nullptr;
        while(p!=nullptr)
        {
            r=p->next;
            p->next=pre;
            pre=p;
            p=r;
        }
        // head=L->next;
        // delete L;
        return head;
    }
};