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

$●  203.移除链表元素 

两总办法都试了一下。

复习的点有几个：

（1）new的用法与malloc用法的区别

ListNode *vitrualL = new ListNode(0);  // 使用 new 创建对象，并初始化头节点的值为0

参考来源：http://t.csdn.cn/wuBE3

（2）指向链表的指针如何移动

phead = phead->next;

（3）如何删除指定节点

 ListNode* tmp = phead->next;
 phead->next = phead->next->next;
delete tmp;

(4)  A && B；先判断A,A成立再判断B

例如这里的

//err:  phead->next != NULL && phead != NULL
//right : phead != NULL && phead->next != NULL
//懂了，换过来的化如果phead本身为空就不存再phead->next所以报错

/**
 * 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) {
        //不用虚拟头节点的办法
            //删除链表前面需要删除的点
            while(head != NULL && head->val == val){
                ListNode * tem = head;
                head  = head->next;
                delete tem;
            }

//删除头节点之后所有需要删除的节点
            ListNode* phead = head;
            //注意两种情况，一种是头节点为空，一种是头节点之后为空都不能再进循环
            //err:  phead->next != NULL && phead != NULL
            //right : phead != NULL && phead->next != NULL
            while( phead != NULL && phead->next != NULL){
                if(phead->next->val == val){
                    ListNode* tmp = phead->next;
                    phead->next = phead->next->next;
                    delete tmp;
                }
                else{
                    //当不需要删除节点的时候让临时指针向下移动一位
                    phead = phead->next; 
                }
            }
            return head;           


    }
};

ListNode* removeElements(ListNode* head, int val) {


        //采用虚拟指针的方法
        ListNode *vitrualL = new ListNode(0);
        vitrualL->next = head;
        ListNode *phead    = vitrualL;

        while(phead->next != NULL){
            if(phead->next->val == val){
                ListNode * temp = phead->next;
                phead->next = phead->next->next;
                delete temp; 
            }
            else{
            phead = phead->next;}
        }
        head = vitrualL->next;
        delete vitrualL;
        return head;
            


    }

●  707.设计链表 

class MyLinkedList {


public:

    //定义链表结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
private:
    int _size;
    LinkedNode * _vHead;

public:
    MyLinkedList() {
        _vHead = new LinkedNode(0);
        _size = 0;

    }
    
    //获取下标为index的值
    int get(int index) {

        if(index >_size-1 |index < 0){
            return -1;
        }
        LinkedNode * tmp = _vHead->next;
        while(index--){
            tmp = tmp->next;
        }
        return tmp->val;


    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _vHead->next;
        _vHead->next = newNode;
        _size++;

    }
    
    void addAtTail(int val) {
        LinkedNode* tmp = _vHead;
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = NULL;
        while(tmp->next != NULL){
            tmp = tmp->next;
        }

        tmp->next = newNode;
        _size++;




    }
    
    void addAtIndex(int index, int val) {
        if(index > _size) return ;
        if(index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* tmp = _vHead;
        while(index--){
            tmp = tmp->next;
        }
        newNode->next = tmp->next;
        tmp->next = newNode;
        _size++; 

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

        }

    


};

/**
 * 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）双指针法

借用一下卡哥的gif来做一下笔记。如下所示就是一前一后的双指针，从头指针开始不断是的cur指向的链表节点的指向反向，直到走到链表最后一个节点的最后一个，这样子pre指针就走到的反转后链表的头节点。（过程中要及时用tmp指针保存cur的下一个位置，用来更新反转后cur指针的指向）

（图来源：代码随想录代码随想录） 

    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
    //双指针法
        while(cur!= NULL){
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;

    }

 （2）递归调用，递归函数中跟新两个指针的指向

    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(cur,tmp);//这里就相当于更新了cur pre两个指针的指向。
    }

    ListNode* reverseList(ListNode* head) {

        head = reverse(NULL,head);
        return head;


    }