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

203.移除链表元素  

题目链接：

看到题目的第一想法：了解链表的结构与特点以及与数组相比较的优缺点，但是不熟悉c++中对链表的操作方式，所以这个题是先学习视频，然后按照给的代码手敲了一遍来熟悉理解对链表的操作方式

看完代码随想录之后的想法：主要就是掌握链表的一些操作方法，如何构建虚拟头节点便于统一操作链表的方式，c++中需要主动释放内存

/**
 * 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);//用new来动态分配内存给ListNode类型的对象其值为0并返回地址给dummyhead
        dummyHead->next=head;               //将虚拟头节点所带的指针放head节点的地址，实现虚拟头节点指向head节点，链接
        ListNode* cur=dummyHead;            //创建一个新的指针存储虚拟头节点的地址用于遍历
        while(cur->next!=0){                //在cur所带的不是空指针的情况下进入循环
            if(cur->next->val==val){
                ListNode* tmp=cur->next;    //新建一个tmp指针用于存储cur所带的指针,目的是在修改cur指向的结点之后对原指向的节点的数据进行释放
                cur->next=cur->next->next;
                delete tmp;
            }else{
                cur=cur->next;              //更新cur实现遍历
            }
        }
        head=dummyHead->next;               //因为一直用的是虚拟头节点，而要返回的是操作结束后的链表的头节点，所以要更改头节点的地址
        delete dummyHead;
        return head;
    }
};

707.设计链表 

题目链接：707. 设计链表 - 力扣（LeetCode）

看到题目的第一想法：实现一个类，包括对象的初始化，get通过索引查找链表中的值，addAtHead在表头插入新的结点，addAtTail在表尾添加新的节点，addAtIndex在想要的索引所指节点的前面插入一个节点，deleteAtIndex删除想要的索引所指向的节点；会一点关于val和指针的初始化声明其他的初始化操作不会；

        get思路是从表头开始遍历通过count++计数找到相应的index；

        addAtHead思路是直接new然后指向原来的head节点，然后把原来的head地址换成new给的；

        addAtTail思路是先new，然后遍历链表用判断条件识别指到空指针的节点，将这个next指向new的地址；

        addAtIndex思路是先new，然后同样是遍历count++到想要的index，这里用单链表的话没有prev所以需要一个temp来存储前一个节点的地址，当遍历到想要的index后就将temp调出将它所带的next指向new的地址，然后将new指向index节点的地址

        deleteAtIndex思路类似于203题

看完代码随想录之后的想法：

        以后的链表操作大部分都使用虚拟节点方便统一操作；

        一般定义cur不能直接操作head因为head一般都是要返回的；

        在插入新节点的时候注意指向的顺序；用极端例子来测试边界条件是否合法，比如说链表只有一个节点时；

        用while(n--)代替我的count++之后if(index==count)，代码更简洁，少了一层判断运行更快；

        用cur和cur->next实现了记忆前后两个节点地址，代替我的新建tmp节点去存储前一个节点地址的方法，占用内存更少，代码运行速度更快

        有很多小细节需要注意；

class MyLinkedList {
public:
    //定义结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}//名为LinkNode的构造函数，其中next初始化为空，表示该节点的下一个节点为空
    };
    //初始化链表
    MyLinkedList() {
        dummyHead=new LinkedNode(0);
        _size=0;//为什么在这里写成 LinkedNode* dummyHead=new LinkedNode(0);int _size=0;会报错
    }

    int get(int index) {
        if(index>(_size-1)||index<0){
            return -1;
        }//首先判断输入的index是否合法，如果为负数或者超出链表的大小的话直接判定为无效，返回-1
        LinkedNode* cur=dummyHead->next;
        while(index--){
            cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode=new LinkedNode(val);
        newNode->next=dummyHead->next;
        dummyHead->next=newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* newNode=new LinkedNode(val);
        LinkedNode* cur=dummyHead;
        while(cur->next!=0){
            cur=cur->next;
        }
        cur->next=newNode;
        _size++;
              
    }
    
    void addAtIndex(int index, int val) {
       
        if(index>_size)return;    //注意可以直接写返回
        if(index<0)index=0;      //注意这种if语句的写法，这个段代码保证了当index小于0时将新的节点插到表头
        LinkedNode* newNode=new LinkedNode(val);
        LinkedNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        newNode->next=cur->next;
        cur->next=newNode;
        _size++;
        
    }
    
    void deleteAtIndex(int index) {
        if(index>=_size||index<0){
            return;
        }
        LinkedNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        LinkedNode* tmp=cur->next;
        cur->next=cur->next->next;
        delete tmp;
        tmp=nullptr;//注意这里的指针tmp的内存释放，被delete后的tmp的值为随机值
                    //如果让tmp=nullptr的话tmp就会成为乱指的野指针
                    //如果之后的程序不小心使用了tmp会指向难以预想的内存空间
                    
        _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);
 */
 void printLinkedList() {
        LinkedNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* dummyHead;
    };

206.反转链表 

题目链接：206. 反转链表 - 力扣（LeetCode）

看到题目的第一想法：构造一个新的数组，对链表进行遍历依次将链表中的值填入数组，然后再次用类似修改链表的值的方式依次遍历填入数；这里的一个问题是给的只是链表的表头地址，所以在建立一个可以刚好容纳链表内的数的数组需要先遍历链表来获得链表的大小

自己写的代码1.0：

/**
 * 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* Head=head;
        ListNode* cur=head; 
        ListNode* tmp=head;
        int i=0;
        int count=0;
        while(Head!=0){
            count++;
            Head=Head->next;
        }
        vector<int> nums(count);
        while(cur!=0){
            nums[i++]=cur->val;
            cur=cur->next;
        }
       
        while(tmp!=0){
            tmp->val=nums[i--];
            tmp=tmp->next;
        }
        return head;
    }
};

堆栈溢出了

看完代码随想录之后的想法：属于没有想到的一种方法，因为对于链表不熟悉，只敢保守操作，没想过直接改指针指向

双指针写法：

/**
 * 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* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};