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

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

一、链表理论基础

​ 链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

​

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表的定义

定义链表节点

// 单链表
struct ListNode{
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
}

初始化节点

ListNode* head = new ListNode(5);

链表的操作

删除节点

1. 定义一个缓存节点temp存放待删除节点D；
2. 将C的next指向next的next；
3. 回收temp；

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

添加节点

1. 开辟一个新节点的空间，并完成新节点的初始化；
2. 让新节点的next指向后一个节点D；
3. 让前一个节点的next指向F；

性能分析

二、移除链表元素

​ 这一道题刚开始看的时候基本没有思路，不了解链表的定义以及基本操作的代码实现，不了解虚拟头节点的定义和用法，看了代码随想录的答案对边界的判定以及初始cur的位置都不是很明白。后面一直在画图演算整个过程，才最后明白移除链表元素的整个操作是什么样的。

​ 当时一直搞不懂的是判定条件为什么是cur->next->val == val；而不是cur->val == val；具体的原因画了个图，(错误示例)如下：

​

ListNode* temp = cur; 

cur = curt->next;
delete temp;

​ 正确代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyNode = new ListNode(0);
        dummyNode->next = 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;
        }
        head = dummyNode->next;
        delete dummyNode;
        return head;
    }
};

三、设计链表

​ 这题非常适合用来熟悉和了解链表的操作，以及虚拟头节点的使用。

class MyLinkedList {
public:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode(int x): val(x), next(NULL){};
    };
    MyLinkedList() {
        _size = 0;
        dummynode = new ListNode(0);
    }
    
    int get(int index) {
        if(index > (_size-1) || index <0) return -1;
        ListNode* cur = dummynode->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        ListNode* newnode = new ListNode(val);
        newnode->next = dummynode->next;
        dummynode->next = newnode;
        _size++;
    }
    
    void addAtTail(int val) {
        ListNode* newnode = new ListNode(val);
        ListNode* cur = dummynode;
        while(cur->next != NULL){
            cur = cur->next;
        }
        cur->next = newnode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index < 0) index=0;
        ListNode* cur = dummynode;
        while(index--){
            cur = cur->next;
        }
        ListNode* newnode = new ListNode(val);
        newnode->next = cur->next;
        cur->next = newnode;
        _size++;
    }
    void deleteAtIndex(int index) {
        if(index > (_size-1) || index < 0) return;
        ListNode* cur = dummynode;
        while(index--){
            cur = cur->next;
        }
        ListNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        _size--;
    }
private:
    int _size;
    ListNode* dummynode;
};

四、反转链表

​ 这里看了思路之后才做的题，但是代码没实现主要是忽略了这一点：链表拷贝赋值的时候拷贝的是整个链表节点包括它的val，以及next；想清楚了就好做出来了。

​ 然后就是递归法了，这种方法是真的很懵，要找个时间在IDE上设计一个小case debug一下整个流程了，并且需要更多题目来练习一下。

// 双指针法
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* temp;
        while(cur){
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

五、总结

​ Day3的算法题拖到昨天才做的，今天又二刷了一遍然后写的博客，感觉对链表的理解更深了一些些，马上去做Day 4的内容了。