第二章 链表part01● 链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

这里是引用

203.移除链表元素

非头结点:这种情况下的移除操作，就是让节点next指针直接指向下下一个节点就可以了.

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* emptyhead = new ListNode(0);
        emptyhead->next = head;
        ListNode* current = emptyhead;
        while (current->next!=nullptr)
        {
            if (current->next->val==val)
            {
                ListNode* tmp = current->next;
                current->next=current->next->next;
                delete tmp;
            }else
            {
                current=current->next;
            }
            
            
        }
        head = emptyhead->next;//head有可能被删掉；
        delete emptyhead;
        return head;
}
};

707.设计链表

表头结点：链表中的第一个结点,包含指向第一个数据元素的指针以及链表自身的一些信息 如长度等，因此下表0表示头size为1，长度和链表相同表示在尾部size包含头结点
c++构造函数初始化列表
在刷leetcode时，发现leetcode中在链表的节点结构体定义为：

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) {}
};
其实这下面三行代码就是构造函数初始化列表，以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式，初始化列表仅在构造函数中有效，不能用于其他函数，可以初始化任何数据成员，包括其他办法不能初始化的const成员。
ListNode节点结构体中三个初始化列表等效于下列表述：

ListNode( ) {
val = 0;
next = nullptr;
}

ListNode(int x) {
val = x;
next = nullptr;
}

ListNode(int x, ListNode *Next) {
val = x;
next = Next
}

初始化列表，他们会在构造函数正式调用前被调用 ，且他们的初始化顺序并不是根据 初始化列表中出现的顺序，而是他们声明的顺序来初始化。

class MyLinkedList {
public:
    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){}
    };
    
    MyLinkedList() {
        this->DummyHead = new ListNode(0);
        this->Lsize = 0;
    }
    
    int get(int index) {
        if (index>=Lsize||index<0)
        {
            return -1;
        }
        
        ListNode* cur = DummyHead->next;//DummyHead只是虚拟，next才是头结点

        while (index--)
        {
            cur = cur->next;        
        }
        return cur->val;
        
    }
    
    void addAtHead(int val) {
        ListNode* tmp = new ListNode(val);
        tmp->next = DummyHead->next;//注意指向头结点
        DummyHead->next = tmp;
        Lsize++;//注意加1
    }
    
    void addAtTail(int val) {
        ListNode*cur = DummyHead;
        while (cur->next!=nullptr)
        {
            cur=cur->next;
        }
        ListNode* NewNode = new ListNode(val); 
        cur->next = NewNode; 
        Lsize++;       
    }
    
    void addAtIndex(int index, int val) {
        if (index>Lsize||index<0)
        {
            return ;
        }
        ListNode* cur = DummyHead;
        while (index--)
        {
            cur = cur->next;
        }
        ListNode* NewNode = new ListNode(val);
        NewNode->next = cur->next;
        cur->next = NewNode;
        Lsize++;        
    }
    
    void deleteAtIndex(int index) {
        if (index>=Lsize||index<0)
        {
            return ;
        }
        ListNode* cur = DummyHead;
        while (index--)
        {
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = nullptr;
        Lsize--;

    }

private:
    int Lsize;
    ListNode* DummyHead;


};

206.反转链表

class Solution {
public:

    ListNode* reverse(ListNode* pre,ListNode* cur)
    {
        if (cur == nullptr)
        {
            return pre;
        }
        
        ListNode* tmp = cur->next;
        cur -> next = pre;

        return reverse(cur,tmp);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(nullptr,head);
    }
};