代码随想录算法训练营第三天| 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) {}
 *     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!=nullptr){
            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;
    }
};

操作某个节点是指向他上一个节点，cur->next来操作下一个节点

数组传入函数用引用: 这样可以避免复制整个数组的开销，同时保持对数组内容的直接访问。引用可以确保传递的数据是原始的，而不是副本。

链表传入函数用指针: 由于链表节点通常是动态分配的，指针允许函数对链表进行修改（如添加或删除节点）。使用指针也更适合链表的结构操作，例如遍历、修改节点等。

箭头操作符 (->):

cur->next 是一种简化的写法，等价于 (*cur).next。箭头操作符 (->) 直接访问指针所指向对象的成员。这种写法避免了显式解引用，使代码更简洁易读。cur->val 是 (*cur).val 的简写，表示对指针所指向的对象的 val 成员的访问。箭头操作符 (->) 是对指针解引用和成员访问的语法糖，提供了一种更简洁、更易于理解的方式来访问指针指向的对象的成员。

707. 设计链表

题目链接

比较复杂，考察链表的各种操作

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}
    };
    MyLinkedList() {
        dummyHead=new LinkedNode(0);
        size=0;
    }
    
    int get(int index) {
        if(index>=size||index<0){
            return -1;
        }
        LinkedNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        return cur->next->val;
    }
    
    void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    void addAtIndex(int index, int val) {
        if(index>size) return;
        if(index<0) index=0;
        LinkedNode* newNode=new LinkedNode(val);
        LinkedNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        newNode->next=cur->next;
        cur->next=newNode;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index>=size||index<0){
            return;
        }
        LinkedNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        LinkedNode* tmp=cur->next;
        cur->next=cur->next->next;
        delete tmp;
        tmp=nullptr;
        size--;
         //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
    }
    void printLinkedaList(){
        LinkedNode*cur =dummyHead;
        while(cur->next!=nullptr){
            cout<<cur->next->val<<" ";
            cur=cur->next;
        }
        cout<<endl;
    }
private:
    int size;
    LinkedNode* 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);
 */

用指针cur遍历指针，结合虚拟头节点，搞清楚遍历到哪个位置。一般对cur遍历到的位置的下一个节点操作。

206. 反转链表

206. 反转链表

双指针法

/**
 * 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* tmp;
        ListNode* pre=nullptr;
        ListNode* cur=head;
        while(cur){
            tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
};

递归法

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);
    }

};