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

链表

个人觉得需要注意的是链表和数组的不同。
数组在内存中是连续的，按序存放的，每次存放数据时，需要在相应的内存中开辟一段连续而完整的内存空间，用来存放相关的数据，因此其可以做到随机访问，其时间复杂度为O(1)。而链表在内存中存放为不连续的，因此其无法进行随机访问，需要依次遍历才能得到所想要的节点，其时间复杂度就比较高O(n)。

203移除链表元素

题目链接:203移除链表元素
题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
本题可使用两种的解题方法：带虚拟头结点和不带虚拟头结点的方法。
从我个人的角度来说，更加喜欢采用带虚拟头结点的方法。采用该种方法就不需要将头结点的情况单独的拿出来讨论，而是和其他节点一般即可。
注意：
在完成链表的相关题目的时候，推荐在纸上进行模拟，而不是用脑子纯想。

带虚拟头结点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        
        ListNode* dumyhead=new ListNode(0);//设置虚拟头结点
        dumyhead->next=head;
        ListNode*cur=dumyhead;
        while(cur->next!=nullptr)
        {
            if(cur->next->val==val)
            {
                ListNode* tmp=cur->next;
                cur->next=cur->next->next;
                delete tmp;
            }
            else{
                cur=cur->next;
            }
        }
        head=dumyhead->next;
        delete dumyhead;
        return head;
        
    }
};

不带虚拟头结点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head!=NULL&&head->val==val)//头结点是val的情况
        {
            ListNode* tmp=head;
            head=head->next;
            delete tmp;
        }
        ListNode* cur=head;
        while(cur!=NULL&&cur->next!=NULL)
        {
            if(cur->next->val==val)
            {
                ListNode* tmp=cur->next;
                cur->next=cur->next->next;
                delete tmp;
            }
            else{
                cur=cur->next;
            }
        }
        return head;
    }
};

707.设计链表

题目链接：707.设计链表
链表作为一个数据结构，在构建链表前，我们必须要先设计节点的结构。
作为一个链表的节点，需要有next指针和val值。
因此，首先构造节点的，采用struct结构体来定义。

struct ListNode//节点的定义和构造函数
    {  
        int val;
        ListNode* next;
        ListNode(int val):val(val),next(nullptr){};
    };

然后，定义链表。
需要有构造函数和相关的属性。

 MyLinkedList() {
        size=0;
        head=new ListNode(0);
    }
 private:
    int size;
    ListNode* head;

在设计了相应的构造函数和私有属性后，即可按照题目要求进行相应的设计了。
注意：题目中不乏缺少插入或删除指定位置的节点，因此，我们首先要判断其索引是否是符合要求的。

int get(int index) {
        if(index<0||index>=size)    return -1;
        ListNode* cur=head->next;
        while(index--)
        {
            cur=cur->next;
        }
        return cur->val;

    }
    
    void addAtHead(int val) {
        ListNode* cur=new ListNode(val);
        cur->next=head->next;
        head->next=cur;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode* cur=head;
        while(cur->next)
        {
            cur=cur->next;
        }
        ListNode* tmp=new ListNode(val);
        cur->next=tmp;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size)  return;
        else if(index==size)    addAtTail(val);
        else if(index<0)    addAtHead(val);
        else{

            ListNode* cur=head;
            while(index--)
            {
                cur=cur->next;
            }
            ListNode* tmp=new ListNode(val);
            tmp->next=cur->next;
            cur->next=tmp;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
         if(index<0||index>=size)
        {
            return;
        }
        ListNode* cur=head;
         while(index--)
        {
            cur=cur->next;
        }
        ListNode* tmp=cur->next;
        cur->next=tmp->next;
        delete tmp;
        size--;

    }

设计时存在问题：在这次链表设计的时候，采用了带有虚拟头结点的方式，好处是在删除和添加的时候非常有利于理解。
因此，还是推荐大家采用带有虚拟头结点的。

206 反转链表

题目链接：206反转链表
同样的对于链表来说要善于画图描述。

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

总结

链表相关的题目，我觉得难点在于其循环条件的判断，到底是while(cur)还是while(cur->next)，特别设置成这两个循环条件下的，循环体如何编写，是比较困难的一件事情。
链表的相关题目，通过画图可以解决绝大部分的问题。
链表同时基本上都是采用双指针的方法。