代码随想录刷题班Day3:链表

1.203移除元素

预备知识：链表，对于链表来说有一个值域和一个指针域，在leetCode中，默认的是头结点是一个存在值的节点，但是对于我们实际编写的时候来说，我们最好是设置一个虚拟头节点。这样可以统一所有节点的操作。

虚拟头节点：对于头结点来说，如果不处理的话，那么我们需要对头结点进行单独的操作，对于虚拟头结点来说的话，我们在头结点前面设置一个dummyHead节点，统一所有的操作。

对于C++来说，我们需要对需要删除的链表数据进行手动释放。

注意的地方：while循环的判断，需要注意的就是如果pre指向的是最后一个结点的时候，我们需要知道的就是空节点是没有指针域和值域。

/**
 * 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* dummyhead = new ListNode(0);
        ListNode* cur = head;
        ListNode* pre = dummyhead;
        dummyhead->next = head;
        while(pre!=nullptr&&pre->next!=nullptr){
            if(cur->val == val){
                ListNode* tmp = cur;
                pre->next = cur->next;//删除这个元素，pre不改变
                cur = cur->next;
                delete tmp;
            }else{
                pre = cur;
                cur = cur->next;
            }
        }
        cur = dummyhead->next;
        delete dummyhead;
        return cur;
    }
};

2.707设计链表

预备知识点：虚拟头结点(head)，链表的相关知识

具体实现：

·虚拟头结点可以保证对应的一个整体的操作的统一

·使用结构体构造对应的一个结点的初始化，并创建一个虚拟头结点，在这个里面head是一个虚拟的头结点

·使用size来记录存在的结点个数，可以帮助我们避免遍历就可以确定是否超出范围，缩短操作时间

·更简单的方法是先设计一个addIndex，然后addHead和addTail就直接调用即可，但是起不到练习的作用了。

class MyLinkedList {
public:
struct LinkNode{
    int val;
    LinkNode* next;
    LinkNode(int val):val(val),next(nullptr){}
};
    MyLinkedList() {
        head = new LinkNode(0);//这是一个虚拟的头结点
        size = 0;
    }
    
    int get(int index) {
        if(index>size-1||index<0){
            return -1;
        }
        LinkNode* cur = head->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkNode* tmp = new LinkNode(val);
        tmp->next = head->next;
        head->next = tmp;
        size++;
    }
    
    void addAtTail(int val) {
        LinkNode* tmp = new LinkNode(val);
        LinkNode* cur = head;
        while(cur->next!=nullptr){
            cur = cur->next;
        }
        cur->next = tmp;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        LinkNode* tmp = new LinkNode(val);
        LinkNode* cur = head;
        if(index>size)return;
        if(index<0) index = 0;
        while(index--){
            cur = cur->next;
        }
        tmp->next = cur->next;
        cur->next = tmp;
        size++;
    }
    
    void deleteAtIndex(int index) {
        LinkNode* cur = head;
        if(index>size-1||index<0){
            return;
        }
        while(index--){
            cur = cur->next;
        }
        LinkNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        size--;
    }
private:
    LinkNode* head;
    int size;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

3.206反转节点

用到的知识点：双指针（pre,cur,next）、链表

难点：你在反转的时候对应的顺序不能变，不然的话，你会出现不连续的情况或者找不到节点的问题。返回值是pre而不是cur，因为最后的时候cur指向nullptr而pre指向的才是最后一个结点。

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