LeetCode Day3 链表: 203.移除链表元素、707.设计链表、206.反转链表

影子修

已于 2024-04-21 21:23:21 修改

阅读量665

点赞数 21

文章标签： leetcode 链表算法

于 2024-04-21 21:17:08 首次发布

本文链接：https://blog.csdn.net/iuhnkjgyi/article/details/137947923

版权

文章介绍了如何使用直接移除节点法和设置虚拟头节点法解决LeetCode中的链表问题，包括移除指定值的节点、在链表特定位置插入和删除节点，以及反转链表。两种方法都详细阐述了解题思路和代码实现。

摘要由CSDN通过智能技术生成

203.移除链表元素

(1) 题目描述

LeetCode 203.移除链表元素

代码随想录:（文字版）

代码随想录:（视频版）

(2) 解题思路

1. 直接移除节点法

/**
 * 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) {
        // 直接移除节点法
        // (1) 当需要删除头节点时
        // head为NULL则无意义
        while (head != NULL && head->val == val ){ // !!! 这里不能是if。特例[7,7,7,7]，if只会删除一个节点
            // (1.1) 移动头节点
            ListNode* tmp = head; // tmp 指要被删除的节点
            head = head->next; // 头节点向后移动一位
            // (1.2) 手动清空已删除的节点内存
            delete tmp;
        } 

        // (2) 当需要删除非头节点时
        // (2.1) 定义临时指针遍历链表，因为头节点不能更改，否则无法return
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){ //cur->next != NULL: 头节点后不能为空
            if(cur->next->val == val){ // 当头节点的下一个节点要被删除
                // (2.1) 移动临时节点
                ListNode* tmp = cur->next; // tmp 指要被删除的节点
                cur->next = cur->next->next;
                // (2.2) 手动清空已删除的节点内存
                delete tmp;
            // (2.3) 遍历寻找下一个要删除的节点
            } else {
                cur = cur->next;
            }
        }
    return head;
    }
};

2. 设置虚拟头节点法

/**
 * 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) {
        // 设置虚拟头节点法
        // (1) 设置一个虚拟头节点，其指向原head
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        // (2) 定义临时指针遍历链表，从虚拟头节点开始。因为头节点不能更改，否则无法return
        ListNode* cur = dummyHead;
        // (2.1) 循环遍历要删除的节点
        while(cur->next != NULL){ 
            if(cur->next->val == val){ // 当头节点的下一个节点要被删除
                // (2.2) 移动临时节点
                ListNode* tmp = cur->next; // tmp 指要被删除的节点
                cur->next = cur->next->next;
                // (2.3) 手动清空已删除的节点内存
                delete tmp;
            // (2.4) 遍历寻找下一个要删除的节点
            } else {
                cur = cur->next;
            }
        }
    // (3) 删除定义的虚拟头节点
    head = dummyHead->next; // 不能直接return head，因为原head可能已经被删除
    delete dummyHead; // 别忘记: 手动清空已删除的节点内存
    return head;
    }
};

好处: 按照统一的方式进行移除

707.设计链表

(1) 题目描述

LeetCode 707.设计链表

代码随想录:（文字版）

代码随想录:（视频版）

(2) 解题思路

本题目要求:

获取链表第index个节点的数值
在链表的最前面插入一个节点
在链表的最后面插入一个节点
在链表第index个节点前面插入一个节点
删除链表的第index个节点

设置虚拟头节点法

class MyLinkedList {
public:
    // 设置虚拟头节点法
    // (1) 定义链表节点结构体，单链表
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}
    };

    // (2) 初始化链表
    MyLinkedList() {
        // (2.1) 设置一个虚拟头节点
        dummyHead = new LinkedNode(0);
        size = 0; // 链表的长度
    }
    
    // (3) 获取链表中下标为 index 的节点的值
    int get(int index) {
        // (3.1) 定义下标index无效范围。如果下标无效，则返回 -1。
        if (index > (size -1) || index < 0) {
            return -1;
        }
        // (3.2) 定义临时指针遍历链表，从虚拟头节点开始
        LinkedNode* cur = dummyHead->next; //dummyHead->next为链表真正的头节点head，head的下标index为0
        // (3.3) 遍历链表，输出index对应的值
        while(index--){ // ??? 如果--index 就会陷入死循环（先减后用）
        // while(index--)（先用后减）== for（int index; index>0; index--）
            cur = cur->next;
        }
        return cur->val;
    }
    
    // (4) 在链表的最前面插入一个节点，值为val
    void addAtHead(int val) {
        // (4.1) 定义一个新节点，值为val
        LinkedNode* newNode = new LinkedNode(val);
        // (4.2) 重新改变指针位置
        // ！！！注意: 改变指针位置的顺序
        newNode->next = dummyHead->next;
        dummyHead->next = newNode;
        size++;
    }

    // (5) 在链表的最后面插入一个节点，值为val
    void addAtTail(int val) {
        // (5.1) 定义一个新节点，值为val
        LinkedNode* newNode = new LinkedNode(val);
        // (5.2) 定义临时指针遍历链表，从虚拟头节点开始
        LinkedNode* cur = dummyHead;
        // (5.3) 开始遍历，寻找插入新节点的位置
        // 当cur->next != nullptr时，cur向后移动，直到:当cur->next == nullptr时，cur为尾节点
        while (cur->next != nullptr){ 
            cur = cur->next; 
        }
        // 此时cur->next == nullptr时，cur为尾节点
        // 在尾节点后cur->next的位置插入新节点
        cur->next = newNode;  // 新节点默认指向nullptr，因此无需设置其指针
        size++;
    }
    
    // (6) 在链表第index个节点前面插入一个节点，值为val
    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    void addAtIndex(int index, int val) {
        // (6.1) 定义下标index无效范围
        // 如果index大于链表的长度，则返回空
        // 如果index小于0，则在头部插入节点
        if (index > size) return;
        if (index < 0) index = 0;
        // (6.2) 定义一个新节点，值为val
        LinkedNode* newNode = new LinkedNode(val);
        // (6.3) 定义临时指针遍历链表，从虚拟头节点开始
        LinkedNode* cur = dummyHead;
        // (6.4) 遍历链表，找到插入新节点的位置
        while(index--){ 
            cur = cur->next; // 插入新节点的位置cur->next
        }
        // (6.5) 重新改变指针位置
        // ！！！注意: 改变指针位置的顺序
        newNode->next = cur->next;
        cur->next = newNode;
    
        size++;
    }
    
    // (7) 删除链表的第index个节点
    // 如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        // (7.1) 定义下标index无效范围
        if (index > (size -1) || index < 0) {
            return;
        }
        // (7.2) 定义临时指针遍历链表，从虚拟头节点开始
        LinkedNode* cur = dummyHead;
        // (7.3) 遍历链表，找到要删除的节点的位置
        while(index--){ 
            cur = cur->next; // 要删除的节点的位置cur->next 
        }
        // (7.4) 删除的节点
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp; // 手动清空已删除的节点内存
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp = nullptr;
        size--;
    }
private: // 将内部变量通过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);
 */

注意:

1. 操作第n个节点: cur指向n-1个节点, cur->next指向第n个节点

即: 删除第n个节点，那么当前遍历的指针cur一定要指向第n个节点的前一个节点

2. 添加节点，注意改变指针的顺序

206.反转链表

(1) 题目描述

LeetCode 206.反转链表

代码随想录:（文字版）

代码随想录:（视频版）

(2) 解题思路

再定义一个新的链表，实现链表元素的反转 --> 对内存空间的浪费

1. 双指针法

定义双指针cur = head，pre = NULL 和临时指针tmp。

NULL --> |__|_| --> |__|_| --> |__|_| --> |__|_| --> |__|_| --> NULL

1) pre cur tmp (tmp保存下一节点指针)

2) pre <-- cur tmp (翻转指针)

3) <-- pre tmp (更新pre)

cur

4) <-- pre cur (更新cur)

tmp

5) <-- pre cur tmp (下一次循环，移动tmp)

.......

end) <-- <-- <-- <-- <-- pre cur (结束循环，直到cur为空)

/**
 * 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) {
        // 双指针法
        // (1) 定义指针
        ListNode* cur = head;  // 初始化
        ListNode* pre = NULL;
        ListNode* tmp; // 临时指针，用来存放下一节点指针
        while(cur != NULL){
            // (2) 翻转指针
            tmp = cur->next;
            cur->next = pre;
            // (3) 更新指针
            // ！！！注意更新顺序
            pre = cur;
            cur = tmp;
        }
        // (4) 反转后的链表head为pre
        return pre; 
    }
};

2. 递归法

基于双指针法，可得到递归法

/**
 * 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* reverse(ListNode* pre, ListNode* cur){
        // (2) 递归结束条件 == 双指针法循环结束条件 --> cur不为空
        //     return: 反转后的链表head为pre
        if (cur == NULL) return pre;
        // (3) 定义临时指针，用来存放下一节点指针 
        ListNode* tmp;
        // (4) 翻转指针
        tmp = cur->next;
        cur->next = pre;
        // (5) 更新指针, 通过递归
        //    pre = cur;
        //    cur = tmp;
        return reverse (cur, tmp);
    }
    ListNode* reverseList(ListNode* head) {
        // 递归法
        // (1) 定义双指针, 初始化
        //  ListNode* pre = NULL;
        //  ListNode* cur = head;  
        return reverse(NULL, head);
    }
};

影子修

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫