day3

203.移除链表元素

题目链接/文章讲解/视频讲解：：programmercarl.com/0203.%E7%A7…

本题思路： 本题较为基础，在大二学习数据结构时以及考研，就多次做过类似的操作，在删除的操作中，可以分为两种类型，一种是带头节点的，而另外一种即为不带头节点的，带头节点的处理相对于简单，而不带头节点的则需要对头节点就是目标删除元素的情况进行处理，同时注意这里采用循环而不是if语句，因为当删除掉目标元素时，又需要对新的头节点进行判断。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head&&head->val==val)        //单独处理需要删除头节点的操作
        {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }
        ListNode* cur = head; 
        while(cur&&cur->next)
        {
            //printf("%d ",cur->val);
            if(cur->next->val == val){      //删除掉当前元素指向的下一个元素等于val的节点
                ListNode* tmp = cur->next;
                cur->next = tmp->next;
                delete tmp;
            }
            else cur = cur->next;          //只有在不执行删除操作时，才将指针前移
        }
        return head;
    }
};

707.设计链表

建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点

题目链接/文章讲解/视频讲解：programmercarl.com/0707.%E8%AE…

本题思路： 本题又是数据结构中一些比较基础的问题，思路简单但操作较为繁琐，因此需要注意各种边界条件，尤其是对链表的创建需要记清楚，本题采用带头节点的方式进行操作，相对于不带头节点的方式，删除操作更为简单，同时由于需要对链表中下标为index的元素进行访问，因此需要记录整个链表的长度，以便更好的操作,注意删除操作中与上述代码不同的操作，（带头节点）。

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<0 || index>(_size-1) )
        {
            return -1;
        }
        int size = index;   
        LinkedNode* cur = _dummyHead->next;
        while(size--)       
        {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode *newtmp = new LinkedNode(val);
        newtmp->next = _dummyHead->next;
        _dummyHead->next = newtmp;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* cur = _dummyHead;
        while(cur->next!=nullptr){
            cur = cur->next;
        }
        LinkedNode* tmp = new LinkedNode(val);
        cur->next = tmp;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
         if (index > _size || index < 0) {
            return;
        }
        int size = index;
        LinkedNode* tmp = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(size--){   //cur为目标前面的节点
            cur = cur->next;
        }
        LinkedNode* curnext = cur->next;
        cur->next = tmp;
        tmp->next = curnext;
        _size++;
    }
    
    // void deleteAtIndex(int index) {
    //     if (index >= _size || index < 0) {
    //         return;
    //     }
    //     LinkedNode *pre = _dummyHead;
    //     LinkedNode *cur = _dummyHead->next;
    //     while(index--){
    //         pre = cur;
    //         cur = cur->next;
    //     }
    //     LinkedNode *tmp = cur->next;
    //     pre->next = tmp;
    //     delete tmp;
    //     _size--;
    // }

    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
    private:
    LinkedNode* _dummyHead;
    int _size;
};

206.反转链表

题目链接/文章讲解/视频讲解：programmercarl.com/0206.%E7%BF…

个人思路： 本题也很基础，只需要遍历一次链表，每次将后面的指针重新指向它的前面节点即可，由于重新指向后，新链表与原先的断开，因此需要记录下原先链表的位置，最后处理当整个链表中只有一个元素的情况。

/**
 * 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 = nullptr;
        while(cur&&cur->next){
            ListNode *tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        if(cur) cur->next = pre;
        head = cur;
        return head;
    }
};