第三天打卡|203.移除链表元素、707.设计链表、206.反转链表

LeetCode203.移除链表元素

题目链接：203.移除链表元素

        注意三个点：1. 当头节点带元素时，考虑头节点的元素是否和val相同，若相同则头节点改变；2. 删除某个节点时，先链接下一个节点再删除；3. 溢出问题。我习惯用指针先指向当前节点下一节点，但是当前节点为NULL时，将指针指向该节点的next会报错。

        //先处理头节点与val相等的情况
        while(head!=NULL && head->val==val){
            ListNode* s = head;
            head = head->next;
            delete s;
        }
        if(head == NULL) return head;//要先判断链表是否为空，否则为q赋初始地址的时候报错
        
        ListNode* p = head;
        ListNode* q = head->next;
        while(p != NULL && q!= NULL){
            if( q->val == val){
                ListNode* s = q;
                p->next = q->next;
                q = p->next;
                delete s;
            }
            else{
                q = q->next;
                p = p->next;
            }
        }
        return head;

LeetCode707.设计链表 

题目链接：707.设计链表      

1. 好久没写类函数了，对于结构体和初始化函数都有些生疏，这次正好复习了。C++定义链表节点时，自主定义构造函数可直接给节点赋值。

public:
    struct LinkeNode{
        int val;
        LinkeNode* next;
        //初始化链表节点
        LinkeNode(int val):val(val),next(nullptr){}
        //之前没见过这种初始化节点的方式，直接在public内定义也可以，不用全局定义
    };

2.  链表定义时，定义虚拟头节点比较方便。能保留空列表，能方便删除和插入第一个元素

MyLinkedList() {
        _size=0;
        _dummyHead = new LinkeNode(0);
    }

3. 在删除元素和加入元素时，一定要记得把链表长度减/增。指向删除节点的指针一定要使之指向nullptr，否则会成为野指针（delete后的指针是随意指向的），一不小心就被用到，造成内存泄漏。 

4.插入、删除节点，最好定位到该位置的前一个节点，方便连接。注意最后一个元素的next指向nullptr，在尾部添加时需注意。

//完整代码
class MyLinkedList {
public:
    struct LinkeNode{
        int val;
        LinkeNode* next;
        //初始化链表节点
        LinkeNode(int val):val(val),next(nullptr){}
        //之前没见过这种初始化节点的方式
    };
    MyLinkedList() {
        _size=0;
        _dummyHead = new LinkeNode(0);
    }
    
    int get(int index) {
        if(index<0 || index >= _size)return -1;
        LinkeNode*p = _dummyHead->next;
        while(index--){
            p = p->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        //在虚拟头节点的后面插入
        LinkeNode*p = new LinkeNode(val);
        p->next = _dummyHead->next;
        _dummyHead->next = p;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkeNode*p = new LinkeNode(val);
        LinkeNode*q = _dummyHead;
        while(q->next != NULL){
            q = q->next;
        }
        q->next = p;
        p->next = NULL;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size || index < 0){return;}
        else if(index == _size){
            addAtTail(val);
        }
        else{
            LinkeNode*p = new LinkeNode(val);
            LinkeNode*pre = _dummyHead;
            while(index--){
                pre = pre->next;
            }
            p->next = pre->next;
            pre->next = p;
            _size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >= _size){
            return;
        }
        else{
            LinkeNode*pre = _dummyHead;
            while(index--){
                pre = pre->next;
            }
            LinkeNode*s = pre->next;//s点为需要删除的节点
            pre->next = s->next;
            delete s;
            _size--;
            s=nullptr;//一定要消除野指针
        }
    }
private:
    int _size;//记录链表长度
    LinkeNode* _dummyHead;//头节点
};

LeetCode206.反转链表

206.反转链表

        刚开始写的时候看到代码中给定了节点的多种定义方式，陷入了误区，实际上不需要重新构造节点，复制节点所带的元素，只用改变指针的指向就好了。用双指针法，注意修改cur指针时，要先保存它指向的下一个位置，否则指针修改后就找不见了。每次是pre先移动，指向cur，cur再移动，指向保留好的后一位数（新链表的前驱）。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr) return head;

        ListNode*pre = nullptr;
        ListNode*cur = head;
        while(cur){
            ListNode*tmp = cur->next;//先保留cur的下一个节点，以免next变化后找不到
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

这几天有点忙，递归算法有时间再研究