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

链表

头指针： 指向链表第一个结点的指针
单链表由表头唯一确定，所以可以用头指针来代表整个链表

定义：

struct ListNode {
    int val;   // 节点上储存的元素
    ListNode *next;   //指向下一个节点的列表
    ListNode(int x):val(x),next(NULL){}      //节点函数的构造（可以给变量赋值）
}

链表的操作
删除节点：改变指针（跳过要删除的那个节点），注意还要再手动释放这个节点（内存）

203.移除链表元素

如果val在头节点又该怎么处理呢？

1. 直接使用原来的链表进行删除 只要将头节点往后移动一位即可 (但这样在写代码的时候要分类处理)
2. 设置一个虚拟头节点进行操作 （统一代码操作，不用分两类）

if 与while 的区别
前者是单次条件判断，后者是重复执行代码

注意本题会定义一个指针，用这个指针来遍历因为本题要返回头节点，所以head指向不能移动，只能再定义一个指针 ListNode*cur = head

是否要添加虚拟头结点：
虚拟头结点的主要目的是为了避免对头结点的特殊处理；这个处理就指的是修改操作。所以可以这样：涉及到对链表修改(如插入，删除，移动)的，都加个dummy，只是遍历取点就可以不用加

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if    
            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;
    }
};

class Solution{
public:
    ListNode*removeElements(ListNote*head,int val){
        ListNode*dummyHead = new ListNode(0);    //设置一个虚拟头节点          
        dummyHead->next = head;                  //下一个指向头节点
        ListNode*cur = dummyHead;                 //定义新指针指向虚拟节点
        while (cur->next!= NULL){
            if(cur->next->val == val){
                cur->next = cur->next->next;
                ListNode*tmp = cur->next;
                delete tmp;
            }else{
                cur = cur->next;
            }
        }
        head = dummyHead->next;            
        delete dummyHead;
        return head;
    }    
};

707.设计链表

class MyLinkedList {
public:
    //定义链表节点
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullprt){}
    };

    //初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
        }
    

    //获取第index个节点数据，非法数值返回-1，从0开始即(头结点)
    int get(int index) {
        if (index >(_size -1)||index < 0){
            return -1;
        }
        LinkedNode*cur = _dummyHead->next;
        while(index--){               //在处理链表时，cur = cur->next 用于遍历链表，而 index-- 用于跟踪还需遍历多少个节点
        cur= cur->next;
        }
        return cue->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!=nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;

    }
    
    void addAtIndex(int index, int val) {
        if(index > _size)

    }
    
    void deleteAtIndex(int index) {

    }
};

206.反转链表

双指针法

class Solution{
poblic:
    ListNode*reverseList(ListNode*head){
        ListNode*temp;      // 保存cur的下一个节点
        ListNode*cur = head;
        ListNode*pre = NULL;
        while(cur){
            temp = cur->next;            
            cur->next = pre;       //翻转
            pre = cur;             //注意顺序！！！
            cur = temp;
        }
        return pre;
    
    }
};

设计链表对我来说是难度plus了，递归也不是很会。就先浅浅记录一下自己会的吧。T_T