DAY3 - 203.移除链表元素, 707.设计链表, 206.反转链表

203.移除链表元素

开始觉得很简单，自信满满写了答案

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}    // 无初始值
 *     ListNode(int x) : val(x), next(nullptr) {}   // val 
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}  // next
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* newhead=new ListNode(0);
        newhead->next=head;
        for(ListNode* p=newhead; p->next!=NULL; p=p->next){
            if(p->next->val==val){
                ListNode* temp=p->next;
                p->next=temp->next;
                delete temp;
            }
        }
        return newhead->next;
    }
};

但是访问越界了，修改了for循环条件： p!=NULL&&p->next!=NULL 结果还是不对。

其实是思路就错了。在删除元素之后 p 不应该直接移向 p->next，而是应该再次判断，所以应该用while来写循环，修改后如下：

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

        return newhead->next;
    }
};

707.设计链表

class MyLinkedList {
private:
    struct Node {
        int val;
        Node *next;
        Node(int val) : val(val), next(nullptr) {}
    };
    
    Node *fhead;  // 链表的虚拟头节点
    int _len;     // 链表长度

public:
    MyLinkedList() {
        fhead=new Node(0);
        // Node *tail=fhead->next;
        _len=0;
    }
    
    int get(int index) {
        if(index>=_len)
            return -1;
        Node *ptr=fhead;
        for (int i=-1; i<index; i++){
            ptr=ptr->next;
        }
        return ptr->val;
    }
    
    void addAtHead(int val) {
        Node *newnode=new Node(val);
        newnode->next=fhead->next;
        fhead->next=newnode;
        _len++;
    }
    
    void addAtTail(int val) {
        Node *newnode=new Node(val);
        Node *ptr=fhead;
        while(ptr->next!=NULL){
            ptr=ptr->next;
        }
        ptr->next=newnode;
        _len++;
    }
    
    void addAtIndex(int index, int val) {
        if(index==_len){
            this->addAtTail(val);
        }else if(index<_len){
            Node *newnode=new Node(val);
            Node *ptr=fhead;
            for (int i=-1; i<index-1; i++){
                ptr=ptr->next;
            }
            newnode->next=ptr->next;
            ptr->next=newnode;
            _len++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index>=_len)
            return;
        Node *ptr=fhead;
        for (int i=-1; i<index-1; i++){
            ptr=ptr->next;
        }
        Node *temp=ptr->next;
        ptr->next=ptr->next->next;
        delete temp;
        temp=NULL;
        _len--;
    }

};


/**
 * 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);
 */

206.反转链表

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

关于条件到底是 p!=NULL (p) 还是 p->next!=NULL 不能想当然，而是要模拟下边界情况（走到最后一个）时候p，q分别是什么才能写边界条件。