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

Leetcode 203 移除链表元素
思路：链表的一道简单题，注意题目要求删除所有值为val的节点，使用while判断而不是if，这里使用了虚拟头节点，使得链表的操作简单了一点

/**
 * 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* dummyHead = new ListNode(0); //创建一个虚拟头节点
        dummyHead->next = head; //将虚拟头节点指向头节点
        ListNode* cur = dummyHead;
        while(cur->next != NULL){ //注意要删除所有节点值为val的节点 这里不是if
            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; //返回新链表头节点
    }
};

Leetcode 707 设计链表
思路：这一题很考查对链表的基本操作，注意要判断index是否为有效值，如果index为无效值则函数直接返回，还要注意增加或删除节点后更新_size即链表长度的值

class MyLinkedList {
public:
    struct linknode{ //定义链表节点
        int val;
        linknode* next;
        linknode(int x):val(x),next(NULL){} //节点构造函数
    };
    MyLinkedList() {
        dummyHead = new linknode(0); //创建虚拟头节点
        _size=0; //链表长度 
    }
    
    int get(int index) {
        if(index<0 || index>(_size-1)) //如果index无效返回-1 
            return -1;
        linknode* cur = dummyHead->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        linknode* newnode = new linknode(val);
        newnode->next = dummyHead->next;
        dummyHead->next = newnode;
        _size++;
    }
    
    void addAtTail(int val) {
        linknode* newnode = new linknode(val);
        linknode* cur = dummyHead;
        while(cur->next != NULL){
            cur = cur->next;
        }
        cur->next = newnode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>_size) //如果index比链表长度大直接返回
            return ;
        linknode* newnode = new linknode(val);
        linknode* cur = dummyHead;
        while(index--){
            cur = cur->next;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index >= _size || index <0 ) //如果index无效则直接返回
            return ;
        linknode* cur = dummyHead;
        while(index--){
            cur = cur->next;
        }
        linknode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = NULL; //要注意给tmp赋值为空 否则tmp会变成野指针
        _size--;
    }
private:
    int _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);
 */

Leetcode 206 反转链表
思路：使用双指针法，定义两个指针pre和cur，依次移动，将cur指向的节点指向pre而不是下一个节点，实现链表的反转。如1->2->3->4->5->NULL，反转为NULL<-1<-2<-3<-4<-5
注意要定义一个临时指针tmp保存cur下一个节点的值，不然cur指向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* cur = head;
        ListNode* pre = NULL; //定义两个指针实现链表反转
        ListNode* tmp; //保存cur的下一节点
        while(cur != NULL){
            tmp = cur->next;
            cur->next = pre; //反转链表指向
            pre = cur; //pre向前移动
            cur = tmp; //cur向前移动
        }
        return pre; //返回头节点 即pre
    }
};