刷题20240112

今天事情多，晚上去打了游戏，半夜回来补一下作业，长话短说了今天

203.移除链表元素

建立虚拟头节点，开辟内存和删除内存，虚拟头节点的好处在于对链表第一个元素的操作更加简易。顺便复习一下删除节点操作，先给指向后删除。（才发现第二题删除节点又忘记delete..

707.设计链表

复习一下结构体，各个函数很基础，但是这个题后面还要多刷刷，做的时候还是挺绕的

index和size是不一样的，类似于数组下标和实际位置，这是很容易出错的地方（真的很讨厌c的这个问题）

206.反转链表

这个题我可印象太深了，尝试用虚拟头节点做一下，但这个题用虚拟头节点反而麻烦，本题类似于双指针，使用暂存指针做中间过渡，但我做力扣的链表题总是担心空指针问题，其实好像不需要。

我猜明天有环形链表判断，还有那个找环形入口的题？猜对了怎么办呢 

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

class MyLinkedList {
public:
    struct LinkNode {
        int val;
        LinkNode* next;
        LinkNode(int val): val(val), next(nullptr){}
    };
    // 初始化MyLinkedList对象
    MyLinkedList() {
        dummyHead = new LinkNode(0);
        size = 0;
    }
    // 获取链表中下标为index的节点的值。如果下标无效，则返回-1
    // index从0开始计算
    int get(int index) {
        if (index > size - 1 || index < 0) return -1;
        LinkNode* cur = dummyHead->next;
        while (index) {
            cur = cur->next;
            index--;
        }
        return cur->val;
    }
    // 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点
    void addAtHead(int val) {
        LinkNode* newnode = new LinkNode(val);
        newnode->next = dummyHead->next;
        dummyHead->next = newnode;
        size++;
        return;
    }
    
    void addAtTail(int val) {
        LinkNode* newnode = new LinkNode(val);
        LinkNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newnode;
        size++;
        return;
    }
    
    void addAtIndex(int index, int val) {
        if (index > size || index < 0) return;
        LinkNode* newnode = new LinkNode(val);
        LinkNode* cur = dummyHead;
        while (index) {
            cur = cur->next;
            index--;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        size++;
        return;
    }
    
    void deleteAtIndex(int index) {
        if (index > size - 1 || index < 0) return;
        LinkNode* cur = dummyHead;
        while (index) {
            cur = cur->next;
            index--;
        }
        if (index == size - 1) {
            LinkNode* temp = cur->next;
            cur->next = nullptr;
            delete temp;
            size--;
            return;
        }
        else if (index < size - 1) {
            LinkNode* temp = cur->next;
            cur->next = temp-> next;
            delete temp;
            size--;
            return;
        }

    }
private:
    int size;
    LinkNode* 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);
 */

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* p1 = head;
        ListNode* p2 = NULL;
        while (p1) {
            ListNode* tmp = p1;
            p1 = p1->next;
            tmp->next = p2;
            p2 = tmp;
        }
        return p2;
    }
};