一刷代码随想录Day3（链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表 ）

链表理论基础

链表的概念：

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null，和火车的结构有点类似，数据域就是车厢，指针域就是车与车之间的连接，但这里的连接是有方向的，由前指向后。

1、如下图的单链表（摘自代码随想录）

2、除了单链表还有双链表，即一个数据域有前后两个指针域，也就是从一个车厢出发与前后都相连,如下图：此时头节点的前指针指向null，尾节点的后指针指向null。

3、循环链表，也就是单链表中的元素首尾相连。

链表与数组储存方式上不同，数组是用连续的内存存储信息，而链表则是散乱地分布在内存各处，用指针相互连接。

链表的定义（基于C/Cpp）

struct Listnode{
    int val;//链表节点数据域
      Listnode* next;//指向下一节点的指针
    Listnode(int v):val(v),next(null){}//构造函数  
};
//若定义了有参构造函数可以如下定义节点：
Listnode* head = new Listnode(5);
//若未定义有参构造函数，使用默认构造函数则声明与初始化必须分开。
Listnode* head = new Listnode();
head->val =5;

定义链表时，都使用head指针指向每个链表，再按顺序将链表节点的head指针赋值给上以节点的next指针。

链表的删除操作：

将需要删除的节点的前一节点的next指针指向下一个保留下来的节点即可，在Cpp中最好还要手动释放（delete）这块内存。

链表的添加操作：

将需要插入的前一节点指向被插入的节点，并将插入节点的nex指向原来的t第二个节点

对数组与链表操作的不同分析：

对于数组而言，增删的时间复杂度为O(n),随机访问的时间复杂度为O（1）

而对于链表而言，增删的时间复杂度为O（1），随机访问的时间复杂度为O（n），因为要一个个向下或向上查找。

203.移除链表元素 

由于删除链表元素的操作上文说到过，在此主要要对删除的情况进行分类讨论：即删除的节点是不是头节点。

有以下两种解法

暴力解法：即直接用条件判断是否是头结点，然后使用不同的删除方法。

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;
    }
};

虚拟头节点法：假设一个dummyNode，其next指针等于head指针，dummyNode不在被删除的范围内，用其作为头节点，原来的头结点就变成的非头节点，可以使用统一的方法进行删除，代码如下

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

注意：cur指向现在访问的节点，在dummyNode方法中，cur从dummy开始，不能直接用dummy进行迭代，一定要借助cur，因为这样能保证输出的时候不会缺少节点。

设计链表：

题目要求：

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

代码如下

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

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--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 != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果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个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    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--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

要一个一个功能实现，不能直接用原来代码修改，容易出错。

反转链表

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

主要思路是使用双指针，一个cur指向当前节点，一个pre指向前一节点，并用pre更新cur的next节点，实现方法有递归法和双指针法，两者本质是相同的。

两组代码如下，递归主要要关注的是不同的情况要有不同的返回，且要让返回之间相互调用才能生效。

class Solution {
public:
ListNode* reverse(ListNode* cur,ListNode* pre){
    if(cur==NULL){
        return pre;
    }
    ListNode* tmp =cur->next;
    cur->next=pre;
     return reverse(tmp,cur);
}
    ListNode* reverseList(ListNode* head) {
       return reverse(head,nullptr);
    }
};//递归代码

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;
    }
};//双指针法