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

题目链接：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);
        dummyHead->next = head;
        ListNode* p = dummyHead;
        while(p->next != NULL) {
            if(p->next->val == val) {
                ListNode* temp = p->next;
                p->next = p->next->next;
                delete temp;
            }else{
                p = p->next;
            }
        }
        return dummyHead->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;
    }
    
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* p = _dummyHead->next;
        while(index--){
            p = p->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newHNode = new LinkedNode(val);
        newHNode->next = _dummyHead->next;
        _dummyHead->next = newHNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* p = _dummyHead;
        LinkedNode* newTNode = new LinkedNode(val);
        while(p->next != nullptr){
            p = p->next;
        }
        p->next = newTNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index < 0) index = 0;  
        LinkedNode* p = _dummyHead;
        LinkedNode* newNode = new LinkedNode(val);
        while(index--){
            p = p->next;
        }
        newNode->next = p->next;
        p->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        LinkedNode* p = _dummyHead;
        LinkedNode* temp;
        if (index < _size && index >= 0) {
            while(index--){
                p = p->next;
            }
            temp = p->next;
            p->next = temp->next;
            _size--;
            delete temp;
        }
    }
private:
    LinkedNode* _dummyHead;
    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);
 */

题目链接：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* temp;
        while(cur){
            temp = cur->next;//暂存下一个，防丢失
            cur->next = pre;//反转
            pre = cur;//跟上脚步
            cur = temp;//去下一个了
        }
        delete temp;
        return pre;
    }
};

图片生动表现了算法步骤（纠正：动画应该是先移动pre，在移动cur）

---

感想

今日任务是对单链表的简单操作和设计，熟练了对单链表这一数据结构的理解和运用，编写实际可运行的代码和笔试伪代码的编写还是有一定差距的，特别是反转链表这块做过好多遍，考前也背过，还需要不断练习才能真正掌握——博观而约取，厚积而薄发。