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

leetcode203移除链表元素

题目描述：

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

这里的链表的不带头结点的链表，移除元素有两种方法

链表定义：

/**
 * 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 && head->val == val){ //检查头结点必须要用while，只要删到头结点值不为val即可，用for的话就麻烦了，我一开始就是用的for
            ListNode* q = head;
            head = head->next;
            delete q;
        }
        ListNode* p = head;
        while(p && p->next){ // 首先要保证p!=null,因为如果链表所有元素都被删光了，此时p就等于null；先p!=null,再p->next!=null
            if(p->next->val == val){
                ListNode* q = p->next;
                p->next = q->next;
                delete q;            
            }
            else p = p->next;  // 必须要有else，不是每一次循环都要变为next,因为可能删完一个节点后，指向的下一个结点也是需要删除的结点，这时候变next，就漏了这个要删的结点了
        }
        return head;
    }
};

方法二：设置虚拟头结点

最后要记得删除虚拟头结点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyhead = new ListNode(0); // 设置虚拟头结点并开辟空间
        dummyhead->next = head;
        ListNode* p = dummyhead;

        while(p->next){// 只要保证p->next!=null即可，因为头结点一定不为null
            if(p->next->val == val){
                ListNode* q = p->next;
                p->next = q->next;
                delete q;
            }
            else p = p->next;
        }
        //这样写很冗余
        // ListNode* q = dummyhead;
        // dummyhead = dummyhead->next;
        // delete q;
        head = dummyhead->next;
        delete dummyhead;

        return head;
    }
};

leetcode707设计链表

之前没怎么用C++写过算法，今天才知道C++中的struct和class基本是通用的，struct也可以用构造函数，并且和class方式一样，这里我发现C++还有很多需要学习，而且我存了一些疑问，比如关于private和public怎么处理，之前学过的也都忘得差不多了，不过以后接触到再学吧。

用的是带虚拟头结点的链表，除了结构体定义和私有变量的定义参考了解析，其余是我自己写的代码

get函数那里，最后不加上判空语句，老是给我报错，参考这篇博文：LeetCodeBug-member access within null pointer of type 'struct ListNode'-CSDN博客，加上了if语句后就通过了

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){} // 构造函数
    };

    MyLinkedList() {  // 初始化链表
        dummyhead = new LinkedNode(0); // 设置虚拟头结点并将头结点的val定为0
        size = 0; // 初始时链表大小为0
    }
    
    int get(int index) {
        LinkedNode* p = dummyhead; // 因为头结点不算在有效结点当中，所以从头结点的下一个开始
        if(index >= size || index < 0){
            return -1;
        }
        else{
            for(int i = 0; i <= index; i++){
                p = p->next;
            }
            if(p) return p->val;  // 不加这个if语句的话老是报member access within null pointer of type'MyLinkedList::LinkedNode' 
            else return -1;
        }
    }
    
    void addAtHead(int val) {
        LinkedNode* p = new LinkedNode(val);
        p->next = dummyhead->next; // 直接加就行
        dummyhead->next = p;
        size++; // 不能忘了
    }
    
    void addAtTail(int val) {
        LinkedNode* p = new LinkedNode(val);
        LinkedNode* q = dummyhead;
        while(q->next) q = q->next;
        q->next = p;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        LinkedNode* p = new LinkedNode(val);
        LinkedNode* q = dummyhead;
        if(index == size){
            while(q->next) q = q->next;
            q->next = p;
        }
        else if(index >= 0 && index < size){
            for(int i = 0; i < index; i++) q = q->next;
            p->next = q->next;
            q->next = p;
        }
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index >= 0 && index < size){
            LinkedNode* p = dummyhead;
            for(int i = 0; i < index; i++) p = p->next;
            LinkedNode* q = p->next;
            p->next = q->next;
            delete q;
            size--;
        }
        
    }

private:
    int size;
    LinkedNode* dummyhead;
};

解析里面关于删除结点，在delete p后，还有一个p=nullptr。解释是这样的：

delete命令指示释放了tmp指针原本所指的那部分内存，被delete后的指针p的值（地址）并非就是NULL，而是随机值。也就是被delete后，如果不再加上一句p=nullptr,p会成为乱指的野指针，如果之后的程序不小心使用了p，会指向难以预想的内存空间。

leetcode206反转链表

我用的是头插法，将链表结点依次插入新链表，由于每次都是插在第一个，最后结果是翻转后新链表。

一开始我写的ListNode* q = p,这样会对head产生影响，必须给q开辟一个空间才行

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* p = head;
        ListNode* NewList = nullptr; // 不带头结点
        while(p){
            ListNode* q = new ListNode(p->val);
            q->next = NewList;
            NewList = q;
            p = p->next;
        }
        return NewList;
    }
};

解析里讲解了两种方法

双指针法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个结点
        ListNode* pre = nullptr; // 新链表
        ListNode* cur = head; // 每次待插的结点
        while(cur){
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

递归法1

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

递归法2

这里的思路是从后往前翻转指针指向

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
};