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

最新推荐文章于 2024-10-31 16:16:13 发布
最新推荐文章于 2024-10-31 16:16:13 发布
阅读量64 收藏
点赞数
文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46176507/article/details/128255007
版权

1-学习的文章和视频链接

1.1 203移除链表元素-代码随想录
1.2 203移除链表元素-卡哥B站视频讲解
1.3 707设计链表-代码随想录
1.4 707设计链表-卡哥B站视频讲解
1.5 206反转链表-代码随想录
1.6 206反转链表-卡哥B站视频讲解

2-题目

203.移除链表元素

<1> 使用原链表

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头节点
        // 如果链表中，从头结点开始每个节点的值都等于val，
        // 删除头节点即可，这也是使用while不使用if的原因
        
        // 链表不能为空 且 头节点的值等于val
        while(head!=NULL && head->val==val){
            ListNode *tmp = head;    // 临时节点等于头节点，用来存储等于val的节点
            head = head->next;       // 移动：头节点等于当前头节点的下一个节点
            delete tmp;              // 删除临时节点
        }

        // 删除非头节点
        ListNode *cur = head;         // 现节点等于头节点，用来移动
        // 链表不能为空 且 现节点的下一节点不能指向空
        while(cur!=NULL && cur->next!=NULL){
            if(cur->next->val==val){  // 现节点的下一节点的值等于val
                // 临时节点等于现节点，用于存储等于val的现节点的下一节点
                ListNode *tmp = cur->next;
                cur->next = cur->next->next;  // 现节点的下一节点等于现节点的下下节点
                delete tmp;
            }
            else // 现节点的下一节点的值与val不等
                cur = cur->next;       // 现节点等于下一节点
        }
        return head;     // 返回链表
    }
};

<2> 使用虚拟头节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 定义一个虚拟头节点，就不用考虑头节点和非头节点的状况了
        ListNode *dummyNode = new ListNode(0);
        dummyNode->next = head;               // 虚拟头节点指向原头节点，表示新链表
        ListNode *cur = dummyNode;            // 定义现节点，等于虚拟节点，用来滑动
        
        // 现节点的下一节点不为空
        while(cur->next!=NULL){
            if(cur->next->val==val){           // 当现节点的下一节点的值等于val
                // 定义一个临时节点等于现节点的下一节点，存储相等值的节点
                ListNode *tmp = cur->next;
                cur->next = cur->next->next;   // 连接到下下节点
                delete tmp;                    // 删除临时节点
            }
            else{                              // 值不相等，跳过
                cur = cur->next;               // 滑动到下一节点
            }
        }
        head = dummyNode->next;                // 返回新链表
        delete dummyNode;                      // 删除虚拟节点
        return head;                           // 返回链表
    }
};
  • 思路：分为使用原链表和虚拟头节点两种方法，主要是记得定义临时节点和现节点，临时节点保存值相等的节点，现节点用来滑动，指向值相等节点的上一个节点。
  • 实现难点：使用原链表时，删除头节点的循环容易写成条件；现节点容易指错，应该指向变动的上一个节点；别忘记在 循环条件中写上链表非空且下一节点非空。
  • 收获：删除元素也不容易，临时节点和现节点的定义很重要。

707.设计链表

class MyLinkedList {
public:
    // 定义单链表结构体
    struct LinkedNode{
        int val;              // 节点的值
        LinkedNode* next;     // 节点指针
        LinkedNode(int val): val(val), next(nullptr){}
    };

    // 初始化单链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0);  // 初始化虚拟节点，不是真头节点
        _size = 0;                       // 初始化链表长度
    }
    
    // 获取第index个节点的值
    int get(int index) {
        // 判断索引合法与否
        if(index>=_size || index<0){
            return -1;
        }
        // 用要取值的节点作为现节点即可，因为无需考虑指针变换操作
        LinkedNode* cur = _dummyHead->next;  // 滑动节点
        while(index--){                      // 先判断index，再减
            cur = cur->next;                 // 一个节点一个节点移动
        }
        return cur->val;                     // 返回现节点的值
    }
    
    // 插入新节点为头节点
    void addAtHead(int val) {
        LinkedNode* newHead = new LinkedNode(val);  // 定义新节点
        // 新节点指向虚拟头节点的下一节点
        newHead->next = _dummyHead->next;
        // 虚拟头节点指向新节点，新节点成为头节点
        _dummyHead->next = newHead;
        _size++;                           // 记得插入后长度加1
    }
    
    // 插入新节点为尾节点
    void addAtTail(int val) {
        LinkedNode* newTail = new LinkedNode(val);  // 定义新节点
        LinkedNode* cur = _dummyHead;               // 定义现节点
        while(cur->next!=nullptr){      // 循环当现节点的下一节点不为空
            cur = cur->next;            // 滑动现节点至下一个节点
        }
        cur->next = newTail;  // 循环到现节点为最后一个节点，插入新节点
        _size++;              // 链表长度加1
    }
    
    // 在第index个节点前添加值为val的新节点
    void addAtIndex(int index, int val) {
        if(index>_size){
            return;
        }
        if(index<0){
            index=0;
        }
        LinkedNode* newNode = new LinkedNode(val);   // 定义新节点
        LinkedNode* cur = _dummyHead;                // 定义现节点
        // 遍历现节点至index
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next;   // 新节点指向现节点的下一节点
        cur->next = newNode;         // 现节点指向新节点
        _size++;                     // 链表长度加1
    }
    
    // 删除第index个节点
    void deleteAtIndex(int index) {
        if(index>=_size || index<0){      // index合法性检查
            return;
        }
        LinkedNode* cur = _dummyHead;     // 定义现节点
        // 滑动节点至index
        while(index--){
            cur = cur->next;
        }
        LinkedNode* tmp = new LinkedNode(0);   // 定义临时节点
        tmp = cur->next;               // 临时节点存储现节点的下一节点
        // 断开现节点和下一节点，而和下下节点连接
        cur->next = cur->next->next;
        delete tmp;                   // 删除临时节点
        _size--;                      // 链表长度减1
    }

    // 打印链表
    void printLinkedNode(){
        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);
 */
  • 思路：首先要定义链表的结构，有其中值和指向下一个节点的指针，两部分组成。获取第index节点的值，每个节点判断时候为index，然后输出。插入新节点在头位置时，新节点指针先指向原头节点，然后把虚拟头节点指向新节点。插入新节点为尾节点时，滑动不是index判断，而是现节点的下一节点的指针是否指向空。在第index个节点前插入新节点时，判断index的合法性，滑动每个现节点直到找到第index节点，新节点指向下一节点，现节点指向新节点。在删除第index个节点时，首先也要判断index的合法性，找到第index个节点，要定义临时节点去储存要删除的节点，下节点指向下下节点，最后要删除临时节点。
  • 实现难点：定义链表长度和虚拟头节点会暴露在初始化；添加或删除节点时，最后一定要变更链表长度；记得现节点指向的是哪个节点。
  • 收获：熟练使用节点的遍历；清楚知道了滑动的现节点应该指向前节点还是本身；熟悉了结构体定义；删除或添加节点的时候，链表长度记得变更。

206.反转链表

<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* reverseList(ListNode* head) {
        ListNode* tmp;              // 定义临时节点
        ListNode* pre = nullptr;    // 定义一个前节点，以便节点反转指向这个前节点
        ListNode* cur = head;       // 定义现节点，从头节开始依次反转
        while(cur){                 // cur直到指向空，退出循
            tmp = cur->next;        // 临时节点保存现节点的原下一节点，因为反转后会丢失连接
            cur->next = pre;        // 现节点指向定义的前节点
            pre = cur;              // 前节点移动到现节点位置(向原链表方向移动一位)
            cur = tmp;              // 现节点移动到临时节点位置(向原链表方向移动一位)
        }
        delete tmp;                 // 删除临时节点
        return pre;                 // 打印反向链表，注意现节点已经指向空，不能作为头节点表示
    }
};

<2> 递归法（双指针思路）

class Solution {
public:
    ListNode* reverse(ListNode* cur, ListNode* pre){
        if(cur==nullptr) return pre;        // 如果现节点指向空，则返回新链表， 新头节点pre
        ListNode* tmp = cur->next;          // 定义临时节点，保存现节点的下一节点
        cur->next = pre;                    // 反向操作，现节点指向前节点
        // 递归，前节点先移动到现节点，现节点再移动到临时节点
        // pre = cur;
        // cur = tmp;
        return reverse(tmp, cur);
    }

    ListNode* reverseList(ListNode* head) {
        // 递归，初始化，现节点指向头节点，前节点指向空
        // cur = head;
        // pre = nullptr;
        return reverse(head, nullptr);
    }
};

<3> 递归法（从后往前翻转）

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边界条件判断，当链表未空或链表中只有1个节点时，返回的都是链表
        if(head==nullptr || head->next==nullptr) return head;
        ListNode* last = reverseList(head->next);   // 递归，从第二个节点开始依次反转
        head->next->next = head;                    // 反转指向
        head->next = nullptr;                       // 原头指为空
        return last;                                // 返回原链表的尾节点
    }
};
  • 思路：双指针法直接定义一前一后2个节点，还要再定义一个临时节点保存后一节点反向时，下一节点丢失的位置，不断移动前后节点，实现反向。用双指针思想的递归方法中，判断cur和pre的位置。从后往前翻转有点难理解，当就是依次链表反转。
  • 实现难点：双指针法中pre和cur节点谁先移动，是有顺序的；双指针思想的递归方法中，cur和pre初始化的值，递归过程中的值，顺序不要搞错；
  • 收获：递归方法很快但是双指针方法更清晰。
飞飞飞超会飞
关注
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
leetcod 203.移除链表元素：
08-24
题目描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。...解题思路有两种：（一）要移除...具体思路详解请看拿捏链表（一）---------移除链表元素
[力扣] 203.移除链表元素
12-23
移除链表元素" 是一个典型的链表操作问题，主要涉及链表节点的删除操作。题目要求从链表中删除所有值等于给定值 `val` 的节点。 链表删除操作通常分为两种情况：删除头节点和删除非头节点。在处理这个问题时，我们...
xiaoxfan#leetcode#203. 移除链表元素1
07-25
示例:输出: 1->2->3->4->5方法一递归func removeElements(head *ListNode, val int) *ListNode
bestlyg#bestlyg-leetcode#203.移除链表元素1
07-25
简介：删除链表中等于给定值val的所有节点。编辑时间：2020.2.13执行用时：1ms内存消耗：40.1MB编程语言：java解法介绍：创建新链表，遍历节点，
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 403
C++ | Leetcode C++题解之第514题自由之路
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 370
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 66
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
最新发布
weixin_47868976的博客
10-31 717
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
算法笔记：Day-04（二维前缀和）
2302_78571314的博客
10-26 453
这道题真的很好，板子题😁。代码第一个方法是构造方法，构造出以左上角为a[0][0],右下角为a[i][j]的矩阵的和所构成的矩阵。然后第二个方法就可以计算任意子矩阵和了。
【深搜算法】（第四篇）
weixin_73861555的博客
10-27 1285
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3634
BSP驱动开发工程师-OS、4 道编程题
算法练习：四数之和
2302_80652761的博客
10-28 296
四数之和
算法有哪些
Mr.xing的博客
10-28 90
算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，代表着用系统的方法描述解决问题的策略机制。也就是说，算法能够对一定规范的输入，在有限时间内获得所要求的输出。算法应该具有有穷性、确切性、输入项、输出项以及可行性这五个重要的特征。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。在各个领域，算法都有着广泛的应用。例如，在数据分析与挖掘中，算法可以帮助开发人员有效地处理和分析海量数据，挖掘数据中隐藏的价值；
leetcode day7 442
m0_75005390的博客
10-27 428
给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 最多两次。请你找出所有出现 两次 的整数，并以数组形式返回。你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间（不包括存储输出所需的空间）的算法解决此问题。输入：nums = [4,3,2,7,8,2,3,1]输入：nums = [1,1,2]输入：nums = [1]
算法的学习笔记—左旋转字符串(牛客JZ58)
业精于勤，荒于嬉
10-27 708
在这道题目中，使用三步翻转法避免了直接拼接带来的额外开销，使得操作更加高效简洁。无论是面试还是实际开发中，这种方法都非常实用。这个题目很好地锻炼了对字符串操作和数组翻转的理解，三步翻转法的思路在其他字符串旋转、数组循环移位等问题中也能得到广泛应用。希望这篇文章能帮助大家掌握并熟练应用这种方法。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【从零开始的LeetCode-算法】3223. 操作后字符串的最短长度
九圣残炎的编程博客
10-26 337
无法对字符串进行任何操作，所以返回初始字符串的长度。请你返回执行完所有操作后，
P11227 [CSP-J 2024] 扑克牌（民间数据）
xiebohang的博客
10-27 234
这道题在洛谷上被评定为红题，也确实挺简单的，就用到了STL里的set，set里的元素不会重复，就只需要把元素放到set里，在计算长度就可以，最后用52减去长度即可。
C语言数据结构：排序(2)
2302_82004664的博客
10-28 869
稳定性指的是相同值相对顺序是否一致，例如：插入排序–稳定希尔排序–不稳定相同的数据预排序的时候分到不同的组，无法控制选择排序–不稳定在最后一次交换的时候，很有可能让确保不了最后的交换顺序堆排序–不稳定冒泡排序–稳定快速排序–不稳定key换到中间的时候也是不可控的归并排序–稳定。
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
本文是关于LeetCode中三道与链表相关的算法题目的刷题笔记，包括203.移除链表元素、707.设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值