代码随想录算法训练营第三天|链表 203. 移除元素 707.设计链表 206.反转链表

203 移除元素

1. C++别忘了内存释放

2. 注意访问空指针的问题

/**
 * 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* removeElements(ListNode* head, int val) {
        //自己写一个虚拟头结点
        ListNode *vir=new ListNode(0,head);
        ListNode *p=vir;
        while((p!=NULL) && (p->next!=NULL))//不加上后面那句，会访问空指针
        {
            if(p->next->val==val)
            {
                ListNode *temp = p->next; //这步是为了可以删除那个结点，释放内存
                p->next=p->next->next;
                delete temp;
                
            }
            else
            {
                p=p->next;
            }
        }
        head=vir->next;
        delete vir;
        return head;
         
    }
};

707 设计链表

1. 用while循环的时候，可以用边界点来确定循环条件，例如 在某点插入元素 ,把n=0 带进while循环试一下

2. 有index的，要检查一下 范围是否合规

3. 写的链表结构体，就是使用 虚拟头结点的

4. 不要用private 的m_size遍历做循环条件，我劝你别乱用

class MyLinkedList {
public:
    //定义链表结构体
    struct linknode
    {
        int val;
        linknode* next;
        linknode(int x):val(x),next(nullptr){}
    };
    MyLinkedList() {
        _dummyhead=new linknode(-1); //这是虚拟头结点，此时链表里面m_size=0
        m_size=0;
    }
    
    int get(int index) {
        
        //下标无效
       // if((index<0)||(index>m_size-1))
        if (index > (m_size - 1) || index < 0)
        {
            return -1;
        }
        else
        {
            linknode *p=_dummyhead->next;
            while(index) //用边界值试一下 比如0 
            {
                p=p->next;
                index--;
            }
            return p->val;
        }

    }
    
    //头插
    void addAtHead(int val) {
        linknode *newnode = new linknode(val);
        newnode->next=_dummyhead->next;
        _dummyhead->next=newnode;
        m_size++;
    }
    
    //尾插
    void addAtTail(int val) {
        //找到最后一个元素，再插入
        linknode *p=_dummyhead;
        /* 我要泪流了，m_size怎么能用来遍历呢，清零了属于是，debug了好久
        while(m_size)
        {
            p=p->next;
            m_size--;
        }
        */
        while(p->next!=nullptr)
        {
            p=p->next;
        }
        linknode *newnode=new linknode(val);
        p->next=newnode;
        m_size++;
    }
    
    //
    //p要指到 index-1的地方
    void addAtIndex(int index, int val) {      
        if(index>m_size)
        {
            return;
        }
        if(index<0) index=0;  
        linknode *p=_dummyhead;
        while(index)
        {
            p=p->next;
            index--;
        }
        linknode *newnode=new linknode(val);
        newnode->next=p->next;
        p->next=newnode;
        m_size++;
        
        
    }
    
    //要指到 index-1的地方
    void deleteAtIndex(int index) {
        if (index >= m_size || index < 0) {
            return;
        }
        linknode *p=_dummyhead;
        while(index)
        {
            p=p->next;
            index--;
        }
        //内存管理，
        linknode *temp=p->next;
        p->next=p->next->next;
        delete temp;
        m_size--;
    }

        // 打印链表
    void printLinkedList() {
        linknode* cur = _dummyhead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }

    private:
        int m_size;
        linknode* _dummyhead ;//虚拟头结点


};

/**
 * 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. 反转链表 

1. 没用pre，明天再写一遍

/**
 * 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 *p=head;
        ListNode *temp;   
        while(p->next!=NULL)
        {
            temp=p->next;
            p->next->next=p;
            p=temp;                 
        }    
        delete temp;
        return p;
    }
};

我的写法之所以不对，是因为第一个的方向没转

/**
 * 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 *temp;   
        ListNode *pre=NULL;
        while(cur!=NULL)
        {
            temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;                 
        }    
        return pre;//这里是pre,不是cur，cur已经为空了
    }
};