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

203. 移除链表元素

链表基础知识

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表相对于数组而言，能够比较容易完成数据添加以及删除，但是查找不便

出现问题

使用过虚拟头节点时没有完成正确定义

代码

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyhead=new ListNode(0);;
        dummyhead->next=head;
        ListNode* cur=dummyhead;
        while(cur->next !=NULL){
            if(cur->next->val==val){
                ListNode* tmp=cur->next;
                cur->next=cur->next = cur->next->next;
                delete tmp;
            }else{
                cur=cur->next;
            }
        }
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }
};

707. 设计链表

出现问题

1.在查找过程中也下意识的写了_size--;查找并不改变总大小

2.定义临时tmp的时候，总是喜欢将tmp删除，tmp删除后会一直报内存错误，只有在删除结点的场景才可以将tmp删除。

3.在删除后，tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针

4.cur常常定义为虚拟头节点的下一位，对虚拟头节点的用法理解还不是很深刻。当出现需要出现对第0个节点插入删除时，头节点便可以便利完成，因此需要将初始cur定义为头节点。

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }
    
    int get(int index) {
        //题目没有说明index的数值，在后续定义的时候，一定要将index里面所有的情况都考虑一下
        if(index >(_size-1) || index<0){
            return -1;
        }
        LinkedNode* cur=_dummyHead->next;
        while(index--){
            cur=cur->next;
            //查找时并不需要size--
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* tmp=_dummyHead->next;
        LinkedNode* cur=new LinkedNode(val);
        _dummyHead->next=cur;
        cur->next=tmp;
        _size++;
        //这里也不能加delete tmp，
        return;
    }
    
    void addAtTail(int val) {
        //虚拟头节点不需要再next了。理解好虚拟头节点
        LinkedNode* cur=_dummyHead;
        LinkedNode* tmp=new LinkedNode(val);
        while(cur->next!=nullptr){
            cur=cur->next;
        }
        cur->next=tmp;
        _size++;
        //原先加了一个delete tmp，但是如果加了之后会导致链表最后一个元素消失，报错
        return;
    }
    
    void addAtIndex(int index, int val) {
        if(index>_size)return;
        if(index < 0) index = 0; 
        LinkedNode* cur=_dummyHead;
        while(index--){
            cur=cur->next;
            }
        LinkedNode* tmp=new LinkedNode(val);
        tmp->next=cur->next;
        cur->next=tmp;
        _size++;
        // 这里不能加delete tmp; 因为tmp就是链表中的元素 
        return;

    }
    
    void deleteAtIndex(int index) {
        if(index>=_size || index<0){
            return ;
        }
        LinkedNode* cur=_dummyHead;
        while(index--){
            cur=cur->next;
        }
        _size--;
        LinkedNode* tmp=cur->next;
        cur->next=tmp->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        return;
    }

private:
  LinkedNode *_dummyHead ;
  int _size;

};

206. 反转链表

这题需要理解 cur->next=pre;pre = cur;时为什么不会类似等号的传递性直接cur->next=cur。

因为链表的节点是一个地址，可以理解为cur->next=一个物理地址了，此时节点名改变的话，并不会改变next的指向

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur=head;
        ListNode* tmp;
        ListNode* pre=nullptr; 
        while(cur){
            ListNode* tmp=cur->next;
            cur->next=pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};