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

LeetCode203.移除链表元素

文章链接：代码随想录
题目链接：203. 移除链表元素

思路：链表问题，设置虚拟头节点，避免特殊情况，简化代码

/**
 * 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* cur = dummyhead;
        while (cur->next != nullptr){
            if (cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
        }
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }
};

LeetCode707.设计链表

文章链接：代码随想录
题目链接：707. 设计链表

自己写了一遍链表的接口，加深了对链表和构建类的理解。

class MyLinkedList {
public:
    MyLinkedList() {
        dummynode = new Linkednode(0);
        size = 0;
    }
    
    int get(int index) {
        if (index < 0 || index >= size){
            return -1;
        }
        Linkednode* cur = dummynode;
        while (index--){
            cur = cur->next;
        }
        return cur->next->val;
    }
    
    void addAtHead(int val) {
        Linkednode* head = new Linkednode(val);
        head->next = dummynode->next;
        dummynode->next = head;
        size++;
    }
    
    void addAtTail(int val) {
        Linkednode* cur = dummynode;
        while (cur->next != NULL){
            cur = cur->next;
        }
        cur->next = new Linkednode(val);
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index >= 0 && index < size){
            Linkednode* cur = dummynode;
            while(index--){
                cur = cur -> next;
            }
            Linkednode* node = new Linkednode(val);
            node -> next = cur -> next;
            cur -> next =  node;
            size++;
        }
        if (index == size){
            Linkednode* cur = dummynode;
            while(index--){
                cur = cur -> next;
            }
            cur -> next = new Linkednode(val);
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index >= 0 && index < size){
            Linkednode* cur = dummynode;
            while(index--){
                cur = cur -> next;
            }
            Linkednode* tmp = cur -> next;
            cur -> next = cur -> next -> next;
            delete tmp;
            tmp = NULL;
            size--;           
        }
    }
private:
    struct Linkednode{
        int val;
        Linkednode* next;
        Linkednode(int val): val(val), next(NULL){}
    };
    int size;
    Linkednode* dummynode;
};

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

注意在delete tmp后，需要加上tmp = NULL,避免tmp成为野指针。

delete tmp;
tmp = NULL;

对于有的题目的示范代码没加 tmp = NULL 语句，在训练营中的相关问答：

LeetCode206.反转链表

文章链接：代码随想录
题目链接：206.反转链表

思路：一种是采用双指针，如下：

/**
 * 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* cur = head;
        ListNode* pre = NULL;
        ListNode* tmp = NULL;
        while (cur){
            tmp = cur -> next;
            cur -> next = pre;

            pre = cur;
            cur = tmp;
        }
        return 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* reverse(ListNode* pre, ListNode* cur){
        if (cur == NULL) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;

        return reverse(cur, tmp);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(NULL, head);         
    }
};

对递归的理解又加深了一些。。

第三天，对于类的构建、指针的内存存储和递归有了更深的理解。加油！！！