day3-代码随想录||链表||203.移除链表元素 707.设计链表 206.反转链表-CSDN博客

开始链表的章节，由于之前对数据结构还算熟悉，基础知识就不再详细回顾了。

这道题初看其实思想不难，就是遍历一边链表，将节点值等于val的节点delete就行了。关键点在于这题给的链表，他的head节点本身就是一个有实际含义的节点，而不是一个空节点。那么在对这种链表进行操作(插入或删除)时，头节点和非头节点的处理方式不同（不理解的话可以自己画图模拟一下），所以必须分开处理。

解法一: 分开处理

对头节点处理：目标-》找到第一个值不为val的节点或者链表删空(即所有节点都为val)。找第一个不为val的节点的目的是: 由于单链表的特性(单向指向)，删除节点需要先找到待删除节点的前一个节点，这样比较好操作。所以我们需要找到第一个值不为val的节点。

对非头节点的处理:这里就比较简单，如果相等就删除cur所指的节点，不过不等cur向后走。

代码如下:

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL) return head;
        
        // 对头节点的操作,找到第一个值不为val的头节点
        while(head != NULL && head->val == val)
        {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 对非头节点操作

        ListNode* cur = head;   // 用cur遍历节点 并且cur要指向当前判断的节点的前一个节点，这样比较方便判断
        while(cur != NULL && cur->next != NULL)
        {
            if(cur->next->val == val) // cur的下一个节点值为val，将cur指向该节点的下一个节点,并删除该节点，
            {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else // cur向前走
            {
                cur = cur->next;
            }
        }
        return head;
    }

};

解法二: 创建虚头节点（使得头节点与非头节点处理一致）

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL) return head;
        
        // 创建带空头节点，使得后续删除操作时，对head的操作和对后面的操作相同
        ListNode* prehead = new ListNode(0);
        prehead->next = head;

        ListNode* cur = new ListNode(0); // 用于遍历链表
        cur = prehead;
        while(cur->next != NULL)
        {
            if(cur->next->val == val)   // 值相同删除该节点
            {
                ListNode* tmp = cur->next;  // 用于释放被删除节点的内存
                cur->next = cur->next->next;
                delete tmp;
            }
            else 
            {
                cur = cur->next; // 遍历向前
            }
        }

        ListNode* newhead = prehead->next;   // 不然老head可能被删除，需要返回新头节点  
        delete prehead;  // 回收空头节点至真
        return newhead;
    }
};

解法三:递归(Carl大神的解)

第一次发现这类题还能递归来做，确实拓宽思路。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 基础情况：空链表
        if (head == nullptr) {
            return nullptr;
        }

        // 递归处理
        if (head->val == val) {
            ListNode* newHead = removeElements(head->next, val);
            delete head;
            return newHead;
        } else {
            head->next = removeElements(head->next, val);
            return head;
        }
    }
};

707.设计链表

一道设计类的题，看似不难，其实存在很多细节，容易写错，由于卡尔大神写的是单链表版本的，我写了一个双向链表的版本。不过在写的过程中一些细节判断还是存在一些问题，不过好在deepseek的加持下，写出来了。

class MyLinkedList {
    // 链表节点
    struct ListNode{
        int val;
        ListNode* pre;
        ListNode* next;
        ListNode(int val):val(val),pre(nullptr),next(nullptr){}
    };


public:
    MyLinkedList() {
        dummyHead = new ListNode(0);
        size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index >=size) return -1;
        ListNode* tmp = dummyHead;
        
        while(index--)
        {
            tmp = tmp->next;
        }
        // // 由于tmp从dummyHead开始走，所以执行index次后，刚好走到get的前一个元素,所以这里要多走一下
        tmp = tmp->next;
        return tmp->val;
    }
    
    void addAtHead(int val) {
        ListNode* tmp = new ListNode(val);
        if(size == 0) // 只有虚头节点
        {
            tmp->pre = dummyHead;
            tmp->next = dummyHead;
            dummyHead->next = tmp;
            dummyHead->pre = tmp;
            size++;
        }
        else
        {
            ListNode* NextNode = dummyHead->next;
            tmp->pre = dummyHead;
            tmp->next = NextNode;
            NextNode->pre = tmp;
            dummyHead->next = tmp;
            size++;
        }
    }
    
    void addAtTail(int val) {
        if(size==0) // 只有虚头节点，头插尾插都相同，直接调用
        {
            addAtHead(val);
            return;
        }
        ListNode* tmp = new ListNode(val);
        // 找到尾节点位置
        ListNode* tail = dummyHead;
        // 这里是关键，双向链表的尾节点应该指向dummyHead而不是空节点，如果是空节点会死循环
        // 因为双向链表的尾节点的next指向dummyHead
        while(tail->next != dummyHead)   
        {
            tail = tail->next;
        }
        // 在尾节点插入
        tmp->next = dummyHead;
        tmp->pre = tail;
        tail->next = tmp;
        dummyHead->pre = tmp;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<0 || index>size) return ; // 插入时，时可以插入到size的，这里要足以
        else if(index==0)
        {
            addAtHead(val);
            return ;
        }
        else if(index==size)
        {
            addAtTail(val);
            return ;
        }
        else
        {
            ListNode* tmp = new ListNode(val);
            ListNode* preInsert = dummyHead;
            while(index--) preInsert = preInsert -> next;   // 找插入的前一个位置
            // 插入
            tmp -> pre = preInsert;
            tmp -> next = preInsert->next;
            preInsert->next->pre = tmp;
            preInsert->next = tmp; 
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index<0 || index > size-1) return;
        ListNode* preNode = dummyHead;
        while(index--) preNode  = preNode -> next;
        ListNode* nextNode = preNode -> next;
        preNode->next = nextNode->next;
        nextNode->next->pre = preNode;
        size--;
        if (size == 0) {
        dummyHead->next = dummyHead;
        dummyHead->pre = dummyHead;
        }
        delete nextNode;
    }
private:
    ListNode* dummyHead;
    int size;
};

206. 反转链表

这道题相对简单，就是创建一个pre节点用于记录前一个节点的位置，一个cur节点不断向后移动即可。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 空节点或只有一个头节点
        if(head == NULL || head->next == nullptr) return head;
        // 有两个及以上的节点
        ListNode* pre = head;
        ListNode* cur = head->next;
        head->next = nullptr;
        while(cur != NULL)
        {
            ListNode* tmp = cur;
            cur = cur->next;
            tmp->next = pre;
            pre = tmp;
        }
        return pre;
    }
};