代码随想录算法训练营day03

题目：203.移除链表元素、707.设计链表、206.反转链表

参考链接：代码随想录

203.移除链表元素

思路：设置虚拟头结点方便操作，比较好理解，对于遍历，如果找到需要删除元素，直接把p指向要删除元素的下一个，否则p和q同时后移。时间复杂度O(n)

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyNode=new ListNode(0);
        dummyNode->next=head;//设置虚拟头结点，方便统一操作
        ListNode* p=dummyNode;
        ListNode* q=head;
        while(q){
            if(q->val==val){
                p->next=q->next;
                delete q;
                q=p->next;
            }
            else{
                p=p->next;
                q=q->next;
            }
        }
        return dummyNode->next;
    }
};

标答删除了虚拟节点，更加严谨，且只用了一个指针遍历，不过思路一样。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

707.设计链表

思路：本题为列表常见操作，我们设置一个具有虚拟头结点的单向列表。然而一开始完成后报错：

class MyLinkedList {
public:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode(int val){//每个节点的初始化
            this->val=val;
            this->next=nullptr;
        }
    };
    ListNode* dummyNode;//虚拟节点
    int size;//长度
    MyLinkedList() {//构造函数
        dummyNode=new ListNode(0);//一开始只有一个虚拟节点
        size=0;
    }
    
    int get(int index) {//下标从0开始
        if(index<0||index>=size){
            return -1;
        }
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        return p->next->val;
    }
    
    void addAtHead(int val) {
        ListNode* newNode=new ListNode(val);
        newNode->next=dummyNode->next;
        dummyNode->next=newNode;
        this->size++;
    }
    
    void addAtTail(int val) {
        ListNode* newNode=new ListNode(val);//新建节点
        ListNode* p=dummyNode;
        while(p->next){
            p=p->next;//找末尾
        }
        p->next=newNode;
        this->size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        ListNode* newNode=new ListNode(val);
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        newNode->next=p->next;
        p->next=newNode;
        this->size--;
    }
    
    void deleteAtIndex(int index) {
        if(index<0 ||index>=size){
            return;
        }
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        p->next=p->next->next;
        this->size--;
    }
};

然而出现报错，对比答案一开始没找出问题，于是加入打印函数来检查：

    void printLinkedList() {
        ListNode* cur = dummyNode;
        while (cur->next) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
        cout << "Length:" << size << endl;
    }

发现是size出了问题，在插入1-2-3后size依旧为1，发现一个极小的错误，即addAtIndex中size++写成了--，细节真的很重要。修改后答案：

class MyLinkedList {
public:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode(int val){//每个节点的初始化
            this->val=val;
            this->next=nullptr;
        }
    };
    ListNode* dummyNode;//虚拟节点
    int size;//长度
    MyLinkedList() {//构造函数
        dummyNode=new ListNode(0);//一开始只有一个虚拟节点
        size=0;
    }
    
    void printLinkedList() {
        ListNode* cur = dummyNode;
        while (cur->next) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
        cout << "Length:" << size << endl;
    }

    int get(int index) {//下标从0开始
        if(index<0||index>=size){
            return -1;
        }
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        return p->next->val;
    }
    
    void addAtHead(int val) {
        ListNode* newNode=new ListNode(val);
        newNode->next=dummyNode->next;
        dummyNode->next=newNode;
        this->size++;
    }
    
    void addAtTail(int val) {
        ListNode* newNode=new ListNode(val);//新建节点
        ListNode* p=dummyNode;
        while(p->next){
            p=p->next;//找末尾
        }
        p->next=newNode;
        this->size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        ListNode* newNode=new ListNode(val);
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        newNode->next=p->next;
        p->next=newNode;
        this->size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0 ||index>=size){
            return;
        }
        ListNode* p=dummyNode;
        for(int i=0;i<index;i++){//循环后p到达index前一个
            p=p->next;
        }
        p->next=p->next->next;
        this->size--;
    }
};

本题给我的启示主要是可以借助打印函数来进行debug，然后是可以将类变量放在private中，比较严谨一点。

206.反转链表

思路：用两个指针p，q遍历相邻两个元素，每次循环，首先用一个中间量保存前节点p，然后将p和q都右移，再将p->next指向前面。直到q为空结束。时间复杂度O(n)

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next){//原链表为空或者只有一个元素
            return head;
        }
        ListNode* r;
        ListNode* p=head;
        ListNode* q=head->next;
        head->next=nullptr;
        while(q){
            r=p;
            p=q;
            q=q->next;
            p->next=r;
        }
        return p;
    }
};

对比标答，我额外处理了head为空和只有一个元素的情况，实际上不需要处理，只需要将遍历的前后指针从null和第一个元素开始即可，我采用的是从第一个元素和第二个元素开始，由于第二个元素可能为空，所以我们多加了一个判断，这是多余的。

去掉初始处理后的写法：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp;
        ListNode* q=head;
        ListNode* p=nullptr;
        while(q){
            tmp=p;
            p=q;
            q=q->next;
            p->next=tmp;
        }
        return p;
    }
};

细看和标答还是不一样，标答用tmp保存的是后指针的下一个节点，而我们保存的是前指针，实际上原理是一样的。

标答：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp;
        ListNode* q=head;
        ListNode* p=nullptr;
        while(q){
            tmp=q->next;
            q->next=p;
            p=q;
            q=tmp;
        }
        return p;
    }
};