算法训练营第3天

题目链接 203. 移除链表元素 & 707. 设计链表 & 206.反转链表
今日学习的文章及视频讲解链接 203. 移除链表元素 & 707. 设计链表 & 206. 反转链表

203.移除链表元素

自己看到题目的第一想法

简单的链表查找和删除操作，需要考虑测试用例2的特殊条件。
需要一个front指针存储此时判断值的节点的上一个节点，这样才能将上一个节点指向下一个节点。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        for (ListNode* i = head, * front = head; i != nullptr; i = i->next) {                
            if (i->val == val) front->next = i->next;
            else front = i;
        }        

        if (head != nullptr && head->val == val) head = head->next;

        return head;
    }
};

看完代码随想录之后的想法

我的第一想法改进版，主动释放内存，同时把特判放到循环内。如果不把特判放到循环内，而只是添加主动释放内存的话，测试用例3会出现释放内存后head front无指向的问题：

// 时复 O(n)，空复 O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* tmp = nullptr, * i = head, * front = head;

        while (i != nullptr) {                
            if (head->val == val) tmp = head, head = head->next, i = head, front = head, delete tmp;
            else if (i->val == val) tmp = i, front->next = i->next, i = i->next, delete tmp;
            else front = i, i = i->next;
        }                

        return head;
    }
};

虚拟头结点：（自己习惯版）

// 时复 O(n)，空复 O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* fake_head = new ListNode(-1, head);
        ListNode* tmp = nullptr, * i = fake_head, * front = fake_head;

        while (i != nullptr) {               
            if (i->val == val) tmp = i, front->next = i->next, i = i->next, delete tmp;
            else front = i, i = i->next;
        }                

        return fake_head->next;
    }
};

自己实现过程中遇到哪些困难

我的第一想法：测试用例3需要特判，否则会跳过第一个节点，同时在进行特判之前进行判空，就像测试用例2一样。
我的第一想法改进版：第一想法直接添加主动释放内存会报错，纠错就是将特判放入循环，针对头节点head。

今日收获，记录一下自己的学习时长

链表操作、主动释放内存、虚节点

707. 设计链表

自己看到题目的第一想法

我已经记不清类和结构体了，直接看随想录了。

看完代码随想录之后的想法

真恶心啊，这种题。对于index的寻找还是不熟悉。

class MyLinkedList {
public:
    struct ListNode {
        int val;
        ListNode* next;
        ListNode() : val(0), next(nullptr) {}
        ListNode(int x) : val(x), next(nullptr) {}
    };

    MyLinkedList() {
        fake_head = new ListNode();
        size = 0;
    }
    
    int get(int index) {
        if (index < 0 || index > size - 1) {
            return -1;
        }

        ListNode* i = fake_head->next;
        while (index--) {
            i = i->next;
        }

        return i->val;
    }
    
    void addAtHead(int val) {
        ListNode* tmp = new ListNode(val);
        tmp->next = fake_head->next;
        fake_head->next = tmp;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode* tmp = new ListNode(val);
        ListNode* i = fake_head;

        while (i->next != nullptr) {
            i = i->next;
        }
        i->next = tmp;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index == size) addAtTail(val);
        else if (index > size) return;
        else {
            ListNode* tmp = new ListNode(val), * i = fake_head;
            while (index--) {
                i = i->next;
            }
            tmp->next = i->next;
            i->next = tmp;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= size) return;
        else {
            ListNode* tmp = nullptr, * i = fake_head;
            while (index--) {
                i = i->next;
            }
            tmp = i->next;
            i->next = i->next->next;
            delete tmp;
            tmp = nullptr;
            size--;
        }
    }

private:
    ListNode* fake_head;
    int size;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

自己实现过程中遇到哪些困难

这道题对于index的寻找是我的难点。

今日收获，记录一下自己的学习时长

C++的类、构造与结构体、链表的整套操作

206.反转链表

自己看到题目的第一想法

没想法，被上一道题恶心到了

看完代码随想录之后的想法

双指针简单易懂

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp; // 保存i的下一个节点
        ListNode* i = head, * pre = nullptr;

        while (i) {
            tmp = i->next;
            i->next = pre;
            pre = i;
            i = tmp; 
        }

        return pre;
    }
};

自己实现过程中遇到哪些困难

无

今日收获，记录一下自己的学习时长

考察对于链表存储的理解