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

文档讲解：代码随想录

视频讲解：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili​​​​​​

帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

数组之后是链表，第三天继续坚持，坚持就是胜利。

203.移除链表元素

感受：一眼看去感觉不难，实际上确实不难，但一切建立在理解的基础上。给个数组让我找其中的目标元素并将其删除，这不直接暴力嘛。实际上相去甚远，因为要考虑的角度偏了，也不应该拿对待数组的那一套面对链表。

思路：依旧是看了卡哥的讲解，简单讲就是通过对头结点的不同处理产生了两种方法，即单独考虑头结点情况和再建一个虚拟结点。由于单链表的特殊性，它只能由前一个结点指向下一个结点，如果要移除的元素不是头结点时，我们直接让头结点next指针域依次指向后一个结点就可以了，但当头结点要被移除时前面已经没有元素指向它，所以我们考虑要么在原有链表中删除，要么再建一个虚拟头结点由它指向实际要被删除的头结点。

第一种操作，我们主要注意要把删除头结点和删除其后的其他结点这两种情况分开考虑即可。上代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head != NULL && head->val == val){
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

重点是第二种操作， 当然并不难，反而不论是理解还是编写起来都更简单。基本思想如上所言，实际的头结点可能会被删除，我们需要建立一个虚拟头结点帮助我们更容易的删除操作。结合代码更好理解：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy_head = new ListNode(0);
        dummy_head->next= head;
        ListNode* cur = dummy_head;
        while(cur != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        return dummy_head->next;
    }
};

707.设计链表

感受：是一道纯粹为了考查而出的题，结合上题我们所说的设置虚拟指针，只要掌握好链表的基本操作就好了。但确实一开始会觉得不耐烦。因为这种题毫无趣味，但基本功其实也就在此刻最能体现出来。（不不不，我的基本功不扎实哈哈）

思路：考察的就是对链表的初始化、增、删操作，直接看代码更好理解：

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    //初始化链表
    MyLinkedList() {
        dummyHead = new LinkedNode(0);
        size = 0;
    }
    //获取第n个结点值
    int get(int index) {
        if(index > (size - 1) || index < 0){
            return -1;
        }
        LinkedNode* cur = dummyHead->next;
        while(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* cur = dummyHead;
        LinkedNode* newNode = new LinkedNode(val);
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        size++;
    }
    //第n个结点前插入结点
    void addAtIndex(int index, int val) {
        LinkedNode* cur = dummyHead;
        LinkedNode* newNode = new LinkedNode(val);
        if(index > size) return;
        if(index < 0) index = 0;
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }
    //删除第n个结点
    void deleteAtIndex(int index) {
        LinkedNode* cur = dummyHead;
        if(index >= size || index < 0){
            return;
        }
        while(index--){
            cur = cur->next;
        }
        LinkedNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        temp = 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;
};

/**
 * 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);
 */

206.反转链表

感受：没看题之前光听名字感觉应该是很难的题，看了题目之后。。呃，just so so嘛。反转链表顾名思义就在反转二字，我们可以简单的理解为要把给定的一个链表里所有元素顺序颠倒过来输出。

思路： 两种方法，但是共用一套逻辑。第一种自然是双指针法，定义一个指针current用来依次遍历每个结点，指针pre用以方便每次遍历每个结点后反转的指向，临时指针temp保存指针pre的结果。代码很简洁：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp;
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur){
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

第二种方法即递归实现，逻辑相同，不多解释，看代码吧：

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

总结：老规矩一句话总结。今天用时共3h，逐渐摸索和掌握了适合我的刷题节奏，继续坚持。