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

LeetCode 203.移除链表元素

题目链接：203.移除链表元素

踩坑：很基础的题，唯一可能出现问题的地方是由于长时间没有写过代码，导致缺少判断head是否为空的条件。

思路：

1. 不使用虚拟头节点：头节点需要单独处理。需要先不断更新head指针来找到可以开始遍历的位置。
2. （推荐）使用虚拟头节点：创建一个节点指向头节点，这样可以将对所有节点的操作统一起来，需要判断指针是否为空的条件也会变少。

代码：

/**
 * 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* dummyhead = new ListNode(0, head);
        ListNode* pre = dummyhead;
        ListNode* p = head;
        while(p != nullptr)
        {
            if(p->val == val)
            {
                ListNode* t = p;
                p = p->next;
                pre->next = p;
                delete t;
            }
            else
            {
                pre = p;
                p = p->next;
            }
        }
        return dummyhead->next;
    }
};

LeetCode 707.设计链表

题目链接：707.设计链表

踩坑：考验的都是链表的基础操作，相对简单，唯一容易出问题的是不熟悉构造链表类需要的组织形式，比如节点在哪定义，结构体构造函数的写法用法，内部变量的定义等。

思路：还是采取有虚拟头节点的结构，注意每个函数在执行时对边界的处理即可，另外注意增删节点后对size修改。

代码：

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

    MyLinkedList() {
        dummyhead = new Node(0);
        size = 0;
    }
    
    int get(int index) {
        if(index > this->size-1) return -1;
        Node* p = dummyhead->next;
        while(index--)
        {
            p = p->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        Node* t = dummyhead->next;
        dummyhead->next = new Node(val);
        dummyhead->next->next = t;
        this->size++;
    }
    
    void addAtTail(int val) {
        Node* p = dummyhead;
        int s = this->size;
        while(s--)
        {
            p = p->next;
        }
        p->next = new Node(val);
        this->size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > this->size || index < 0) return;
        else if(index == this->size) addAtTail(val);
        else if(index == 0) addAtHead(val);
        else
        {
            Node* pre = dummyhead;
            Node* p = dummyhead->next;
            while(index--)
            {
                pre = p;
                p = p->next;
            }
            pre->next = new Node(val);
            pre->next->next = p;
            this->size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index < this->size && index >= 0)
        {
            Node* p = dummyhead->next;
            Node* pre = dummyhead;
            while(index--)
            {
                pre = p;
                p = p->next;
            }
            Node* t = p;
            p = p->next;
            pre->next = p;
            delete t;
            this->size--;
        }
    }
    private:
    int size;
    Node* 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);
 */

LeetCode 206.反转链表

题目链接：206.反转链表

踩坑：看到这道题第一眼本来想用双指针或者三指针来写，但是好死不死看到了进阶要求（可以用递归），那就必须挑战一下了。我自己的递归算法其实没什么坑，只是一开始思路没有捋顺有点生草。重要的是，考虑递归时，从函数本身的作用，传入参数，返回值入手往往会得到思路。

思路：
这道题的核心就是解决一个节点反转后会失去其原来的next节点的地址，只要用临时变量或者三指针保存下来即可。

1. 双指针或三指针：如上所述
2. 卡哥的递归：卡哥递归的方法感觉更像是循环的简化，因为整个过程还是不断地进行1<-2, 2<-3, 3<-4。
3. 我的递归：感觉我自己的方法更贴合递归两个字的含义，体现出了把复杂问题简单化的逻辑，即将当前链表全部反转等同于将除头节点外的链表全部反转后把头节点挂在尾部。同时也付出了时间和空间上的代价。

代码：

// 我的递归
/**
 * 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) {
        if(head == nullptr || head->next == nullptr) return head;
        // 反转除头节点外的链表，同时返回新链表的头指针（为了满足题目）
        ListNode* new_head = reverseList(head->next);
        
        ListNode* p = new_head;
        while(p->next != nullptr) p = p->next;
        p->next = head;
        head->next = nullptr;
        return new_head;
    }
};