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

想法：链表还是相对熟悉的一个part，相信今天可以表现的不错 (os: 链表题在面试中也是很经常要被用到的)

理解：链表节点的连接就通过next指针来指向；在删除节点的时候，需要注意手动释放中间节点（被删除的），做到前后连接；在添加节点的时候，需要记得保存下一节点，避免找不到指向的问题

链表类的书写：面试可能会用到

class Node {
    public:
        int val;
        Node* next;
        Node(int _val) {
            val = _val;
        }
};

203. 移除链表元素

想法：创建虚拟头节点，因为涉及到可能头节点的删除；并且需要注意手动释放删除节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==nullptr) {
            return nullptr;
        }
        ListNode* newHead = new ListNode(-1);
        newHead->next = head;
        ListNode* pre = newHead;
        ListNode* cur = newHead->next;
        while(cur!=nullptr) {
            if(cur->val == val) {
                ListNode* delNode = cur;
                pre->next = cur->next;
                cur = pre->next;
                delete delNode;
            }else {
                cur = cur->next;
                pre = pre->next;
            }
        }
        head = newHead->next;
        delete newHead;
        return head;
    }
};

707. 设计链表

想法：需要指向头和指向尾的指针来标注这个链表的位置

阅读后想法：通过虚拟节点的方式可以节省不少功夫（尤其删除）

思路：判断好条件就好 (os: 太累了上班，没时间整理了)

class MyLinkedList {
public:
    class ListNode {
        public:
            int val;
            ListNode* next;
            ListNode(int _val) {
                val = _val;
                next = nullptr;
            }
    };

    MyLinkedList() {
        newHead = new ListNode(-1);
        size = 0;
    }
    
    int get(int index) {
        if(index<0 || index>=size) {
            return -1;
        }
        ListNode* cur = newHead;
        while(index-->=0) {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        ListNode* cur = new ListNode(val);
        cur->next = newHead->next;
        newHead->next = cur;
        size++;
    }
    
    void addAtTail(int val) {
        int index = size;
        ListNode* cur = newHead;
        while(index--) {
            cur = cur->next;
        }
        cur->next = new ListNode(val);
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size) {
            return;
        }
        if(index<0) {
            index = 0;
        }

        ListNode* cur = newHead;
        while(index--) {
            cur = cur->next;
        }
        ListNode* Node = new ListNode(val);
        Node->next = cur->next;
        cur->next = Node;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0 || index>=size) {
            return;
        }
        ListNode* cur = newHead;
        while(index--) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        size--;
    }
private:
    ListNode* newHead;
    int size;

};

206. 反转链表

想法：需要三个指针，pre\cur\next，进行轮询替换next指针

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr) {
            return nullptr;
        }

        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* next = nullptr;
        while(cur!=nullptr) {
            next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};