代码随想录刷题day03

203.移除链表元素- 力扣（LeetCode）

思路：先创建一个哑结点，用于处理可能存在的头结点需要删除的情况，然后遍历整个链表，如果碰到需要下一节点需要删除，就直接让当前节点指向下下个节点，最后返回链表

代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
            ListNode* dummy = new ListNode(0, head);//创建哑结点，用于处理头结点需要删除的情况
            ListNode* tmp = dummy;

            while(tmp->next != nullptr)//遍历链表
            {
                if(tmp->next->val == val)
                {
                    ListNode* todelete = tmp->next; //创建需要删除的链表节点
                    tmp->next = tmp->next->next;
                    delete todelete;//释放内存
                }
                else tmp = tmp->next;
            }
            return dummy->next;
    }
};

206.设计链表 - 力扣（LeetCode）

思路：理解链表5种操作的综合题

需要注意的事项：

1.每次增减操作后，链表的长度size也要对应改变

2.进行索引相关的操作时，需要注意索引的越界

3.建立哑结点可以不用单独考虑对头节点的增减，使后面的所有节点的操作逻辑相同

4.如果需要增加操作，可以先new建立一个新节点，然后根据要求指向对应节点

5.增删操作需要将原链表中的某条链删除，指向新的节点后再指向原节点后面的元素

代码：

class MyLinkedList {

public:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode(int x):val(x),next(nullptr){};
};

    ListNode* _dummy;//建立哑结点
    int size;

    MyLinkedList() {
        _dummy = new ListNode(0);//初始化
        size = 0;
    }
    
    int get(int index) {
        if(index >= size || index < 0) return -1;//索引越界的两种情况
        ListNode* cur = _dummy->next;//此时cur表示为传统意义的head
        while(index--)
        {
            cur = cur->next;//找到index下的节点
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        ListNode* tmp = new ListNode(val);//建立新节点，用来指向原先head节点指向的元素
        tmp->next = _dummy->next;
        _dummy->next = tmp;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode* tmp = new ListNode(val);
        ListNode* cur = _dummy;
        while(cur->next != nullptr)//原理同增加头结点
        {
            cur = cur->next;
        }
        cur->next = tmp;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > size) return;
        if(index < 0 ) index = 0;//如果索引小于0,则从第一个开始
        ListNode* cur = _dummy;
        while(index--)
        {
            cur = cur->next;
        }
        ListNode* tmp = new ListNode(val);
        tmp->next = cur->next;
        cur->next = tmp;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index >= size || index < 0) return;
        ListNode* cur = _dummy;
        while(index--)
        {
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = nullptr;//需要注意tmp可能成为野指针
        size--;
        }
};

206. 反转链表 - 力扣（LeetCode）

思路：如果直接在原链表上面进行翻转，则需要将原head指针变成NULL，因此首先定义两个指针分别指向head和NULL，然后一个空链表用于储存需要每一次需要反转的元素。每一次指向结束后，将两个指针往后移动，直到遍历完整个链表元素。

下图是每次pre指针和cur指针的移动顺序，()里面的值表示每次更新后的元素

代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp;
        ListNode* cur = head;
        ListNode* pre = NULL;

        while(cur)
        {
            tmp = cur->next;
            cur->next = pre;

            pre = cur;
            cur = tmp;
            
        }
        return pre;
    }

};