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

203.移除链表元素

建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

基本思想：对链表进行遍历，找到与val相等的节点，将该节点前面的指针指向后面的指针

这里需要借助虚拟指针dummyHead。关于什么时候添加虚拟头结点：

虚拟头结点的主要目的是为了避免对头节点的特殊处理，因为本题需要返回头结点，所以涉及到对链表修改（比如插入、删除、移动）的，都加个dummyHead，如果只是遍历取点的话，就不用加上。

具体代码

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0, head);//新建虚拟头结点，dummyHead指向head
        ListNode* cur = dummyHead;
        while (cur->next){
            if (cur->next->val == val){ //找到了，就将指针指向下一个指针
                cur->next = cur->next->next;
            }else{
                cur = cur->next;
            }
        }
        return dummyHead->next;//返回头结点
    }
};

还要考虑的是循环的跳出条件，是cur还是cur->next，这里考虑到删除链表的操作，将cur->next=cur->next->next，所以cur->next不能为空，否则cur->next->next就会溢出。

707.设计链表

建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点

这道题函数有点多，写的时候有难度

定义链表节点结构体

方便后面定义新的节点，包括节点值和指向的下一节点

struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

链表初始化

 MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 定义了一个虚拟头结点，并不是真正的链表头结点
        _size = 0;
    }

获取第index个节点数值

如果索引值大于链表的最大索引，或者说index小于0，直接返回-1；通过index--来控制cur的移动，

int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;//让虚拟头节点指向cur
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

在链表最前面插入一个节点

这里需要新建一个节点，该节点的数值为val，最前面插入，即将新建节点指向头结点，同时虚拟头节点指向新建节点，链表的长度加1

void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

在链表的最后面添加一个节点

和上面相似，但是需要将cur移动到末尾，并指向新建节点。

void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

在链表中的第 index 个节点之前添加值为 val  的节点

如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

这里需要考虑index的大小，若超过链表的最大索引或者小于0，都需要另外处理，通过index--将cur移动到需要插入的位置，令新建节点指向cur->next，cur则指向新建节点。

删除第index个节点

首先同样是对索引index的判断，将cur移到需要删除的位置，令cur->next=cur->next->next就能删除该节点，使用中间变量tmp记录要删除的节点，最后使用delete删除，同时链表长度减1；

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;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

206.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

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

这里需要注意的是，中间变量tmp的指向，有些类似于数组元素交换位置的写法。因为需要进行链表的反转，所以要新建一个节点pre=nullptr，作为反转后链表的尾部。

Note：new ListNode()是真实存在的一个节点, head = new ListNode() 相当于 head指针指向了一个真实的节点, node = head, 相当于node和head同时指向了这个真实的节点