代码随想录Day6-链表：力扣203、707题

已于 2023-07-30 11:38:45 修改
阅读量55 收藏
点赞数
分类专栏： 代码随想录 文章标签： 链表 leetcode 数据结构 c++ 算法
于 2023-07-29 21:42:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jerome_zp/article/details/131997038
版权

203. 移除链表元素

题目链接
代码随想录文章讲解链接

方法一：直接移除

思路

直接移除满足条件的节点，但是对于头结点和非头结点的移除逻辑不同，所以要分别进行操作。

  • 时间复杂度： O ( n ) O(n) O(n)
  • 空间复杂度： O ( 1 ) O(1) O(1)
C++代码
/**
 * 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 != nullptr && head->val == val) {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }
        // 删除非头结点
        ListNode* cur = head;
        while (cur != nullptr && cur->next != nullptr) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

方法二：使用虚拟头结点

思路

方法一需要分别处理头结点和非头结点，可以首先在链表头设置一个虚拟头结点，这样就能统一原本的头结点和非头结点的操作，使代码逻辑更加简洁，最后再返回虚拟头结点的next。

  • 时间复杂度： O ( n ) O(n) O(n)
  • 空间复杂度： O ( 1 ) O(1) O(1)
C++代码
/**
 * 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* preHead = new ListNode(0, head);
        ListNode* cur = preHead;
        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 = preHead->next;
        delete preHead;
        return head;
    }
};

看完讲解的思考

无

代码实现遇到的问题

太久没处理各种数据结构了，对于指针的操作一开始没理清楚。

707. 设计链表

题目链接
代码随想录文章讲解链接

方法一：单链表

思路

经典单链表的操作，重点在于设置虚拟头结点，不设置虚拟头结点的话代码逻辑会很复杂。

  • 时间复杂度：get是 O ( i n d e x ) O(index) O(index)，addAtHead是 O ( 1 ) O(1) O(1)，addAtTail是 O ( n ) O(n) O(n)，addAtIndex是 O ( i n d e x ) O(index) O(index)，deleteAtIndex是 O ( i n d e x ) O(index) O(index)。
  • 空间复杂度：不考虑链表本身的存储空间的话，所有操作都为 O ( 1 ) O(1) O(1)。
C++代码
class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val) : val(val), next(nullptr) {}
    };

    MyLinkedList() {
        this->_size = 0;
        this->_dummyHead = new LinkedNode(-1);
    }
    
    int get(int index) {
        if (index < 0 || index >= this->_size) return -1;
        LinkedNode* cur = this->_dummyHead->next;
        for (int i = 0; i < index; ++i) cur = cur->next;
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = this->_dummyHead->next;
        this->_dummyHead->next = newNode;
        ++this->_size;
    }
    
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = this->_dummyHead;
        while (cur->next != nullptr) cur = cur->next;
        cur->next = newNode;
        ++this->_size;
    }
    
    void addAtIndex(int index, int val) {
        if (index >= 0 && index <= this->_size) {
            LinkedNode* cur = this->_dummyHead;
            LinkedNode* newNode = new LinkedNode(val);
            for (int i = 0; i < index; ++i) cur = cur->next;
            newNode->next = cur->next;
            cur->next = newNode;
            ++this->_size;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index >= 0 && index < this->_size) {
            LinkedNode* cur = this->_dummyHead;
            for (int i = 0; i < index; ++i) cur = cur->next;
            LinkedNode* delNode = cur->next;
            cur->next = delNode->next;
            delete delNode;
            delNode = nullptr;
            --this->_size;
        }
    }

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);
 */

方法二：双向链表

思路

经典双向链表的操作，重点在于设置虚拟头结点和虚拟尾结点，不设置虚拟头尾结点的话代码逻辑会很复杂。

  • 时间复杂度：get是 O ( m i n { i n d e x , s i z e − 1 − i n d e x } ) O(min\{index, size-1-index\}) O(min{index,size−1−index})，addAtHead是 O ( 1 ) O(1) O(1)，addAtTail是 O ( 1 ) O(1) O(1)，addAtIndex是 O ( m i n { i n d e x , s i z e − i n d e x } ) O(min\{index, size-index\}) O(min{index,size−index})，deleteAtIndex是 O ( m i n { i n d e x , s i z e − i n d e x } ) O(min\{index, size-index\}) O(min{index,size−index})。
  • 空间复杂度：不考虑链表本身的存储空间的话，所有操作都为 O ( 1 ) O(1) O(1)。但是双向链表相对于单链表需要额外的存储空间来存储prev。
C++代码
class MyLinkedList {
public:
    // 定义双链表结点结构体
    struct DLinkedNode {
        int val;
        DLinkedNode* next;
        DLinkedNode* prev;
        DLinkedNode(int val) : val(val), next(nullptr), prev(nullptr) {}
        DLinkedNode(int val, DLinkedNode* next, DLinkedNode* prev) : val(val), next(next), prev(prev) {}
    };

    MyLinkedList() {
        this->_size = 0;
        this->head = new DLinkedNode(-1);
        this->tail = new DLinkedNode(-1);
        this->head->next = this->tail;
        this->tail->prev = this->head;
    }
    
    int get(int index) {
        if (index < this->_size && index >= 0) {
            DLinkedNode* cur;
            if (index < (this->_size - 1) / 2) {
                // 要获取的结点位于链表前半段
                cur = this->head->next;
                while (index--) cur = cur->next;
            } else {
                // 要获取的结点位于链表后半段
                cur = this->tail->prev;
                while (index++ < this->_size - 1) cur = cur->prev;
            }
            return cur->val;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        DLinkedNode* newNode = new DLinkedNode(val, this->head->next, this->head);
        this->head->next->prev = newNode;
        this->head->next = newNode;
        ++this->_size;
    }
    
    void addAtTail(int val) {
        DLinkedNode* newNode = new DLinkedNode(val, this->tail, this->tail->prev);
        this->tail->prev->next = newNode;
        this->tail->prev = newNode;
        ++this->_size;
    }
    
    void addAtIndex(int index, int val) {
        if (index <= this->_size && index >= 0) {
            if (index <= this->_size / 2) {
                // 要增加的结点的位置位于链表前半段
                DLinkedNode* cur = this->head;
                while (index--) cur = cur->next;
                DLinkedNode* newNode = new DLinkedNode(val, cur->next, cur);
                cur->next->prev = newNode;
                cur->next = newNode;
            } else {
                // 要增加的结点的位置位于链表后半段
                DLinkedNode* cur = this->tail;
                while (index++ < this->_size) cur = cur->prev;
                DLinkedNode* newNode = new DLinkedNode(val, cur, cur->prev);
                cur->prev->next = newNode;
                cur->prev = newNode;
            }
            ++this->_size;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index < this->_size && index >= 0) {
            DLinkedNode* delNode;
            if (index <= this->_size / 2) {
                // 要删除的结点位于链表前半段
                DLinkedNode* cur = this->head;
                while (index--) cur = cur->next;
                delNode = cur->next;
                delNode->next->prev = cur;
                cur->next = delNode->next;
            } else {
                // 要删除的结点位于链表后半段
                DLinkedNode* cur = this->tail;
                while (index++ < this->_size - 1) cur = cur->prev;
                delNode = cur->prev;
                delNode->prev->next = cur;
                cur->prev = delNode->prev;
            }
            delete delNode;
            delNode = nullptr;
            --this->_size;
        }
    }

private:
    int _size;
    DLinkedNode* head;
    DLinkedNode* tail;
};

/**
 * 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);
 */

看完讲解的思考

划重点：单链表要设置虚拟头结点！双向链表要设置虚拟头尾结点！
可以大大简化代码逻辑。
对某个结点进行删除或者在某个结点之后添加新结点的操作，一定是遍历到目标结点的前一个结点进行操作。例如：要删除第5个结点，则要遍历到第4个结点，然后对第5个结点进行删除；要在第5个位置添加结点，则要遍历到第4个结点，然后在后面添加新结点。
该题还可以用其他链表实现，例如循环链表，但目前水平有限，之后二刷再来填坑。

代码实现遇到的问题

因为没有设置虚拟头结点，导致代码逻辑混乱，一堆bug…

最后的碎碎念

今日的数据结构链表太久没写了，折腾了半天，第二题搞了一晚上，今天就刷两题吧。

猪扒已出闸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题库-LeetCode:力扣题库
06-29
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。它包含了各种难度级别的编程问题，涵盖了多种编程语言，如Java、Python、C++等。LeetCode题库提供了丰富的算法题目，...
leetcode备忘录系统-LeetCode:力扣是宝贵的存款
06-30
leetcode备忘录系统力扣是宝贵的存款 一群Bpt码农，天天码字！！ 总体方案如下： 一天一题 以周为单位，其中简单、中等、困难的比例为 3:2:2 每天早上8点发表题，晚上11点给出今天最好的投稿 标题类型顺序： 第一...
代码随想录Day7-链表：力扣206、24、19题
Jerome_zp的博客
07-30 28
今日刷题较为顺利，但是刷题速度还是有很大提升空间。连续刷题一周达成✌，做题找回以前的感觉了。
【代码随想录】Day3&4链表：力扣203，707，206，142，面试0207
weixin_53043309的博客
12-19 358
/ 单链表int val;// 节点上存储的元素// 指向下一个节点的指针ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数};//也可以不定义构造函数，使用默认构造函数，但是这个构造函数不会初始化任何成员变量//自己定义的构造函数//默认构造函数。
代码随想录刷题Day3链表(力扣203,209,707)
dhrmt的博客
07-05 403
/ 节点类int data;Node next;// 添加元素到链表末尾} else {= null) {// 删除链表中的第一个元素if (head!= null) {// 查找元素= null) {// 打印链表= null) {// 输出: 1 2 3// 输出: 2 3// 输出: true// 输出: false// 节点类int data;Node prev;Node next;
代码随想录Day22-二叉树：力扣第701m、450、669m、108e、538m题
Jerome_zp的博客
09-05 34
二叉树专题完结撒花~
代码随想录(day03)-LeetCode：203、707、206
qq_43527980的博客
12-30 301
LeetCode（Java）：203题（移除链表元素）、707题（设计链表）、206题（反转链表）
代码随想录Day8-链表&哈希表：力扣面试题02.07、142、242题
Jerome_zp的博客
07-31 96
链表章节结束，进入一下章节哈希表咯。
代码随想录Day4--链表part02
B7_0729的博客
01-28 969
随着进度推进，感觉题目也越来越难了。今天的任务更重要，继续升级！
代码随想录Day3 - 链表 | 203. 移除链表元素、707. 设计链表
Genelove1974的博客
12-31 91
代码随想录Day3 - 链表 | 203. 移除链表元素、707. 设计链表
代码随想录刷题Day4链表(力扣19,24,07)
dhrmt的博客
07-07 220
代码中采用了虚拟头节点。这样慢指针最终指在目标的前一个，删除即可。本题很妙，需要用两个指针来控制“倒数第几个”这个概念。本题容易出现空指针的问题，要使用。做法是快慢指针，需要公式的推导。
leetcode题库-LeetCode:力扣题库解决方案
06-29
这个“leetcode题库-LeetCode:力扣题库解决方案”很可能是某个开发者或团队分享的他们在解决LeetCode问题时的代码库。这个开源项目可能包含了多种编程语言的解题方案，比如Python、Java、C++等。 在这个"LeetCode-...
leetcode答案-LeetCode:力扣答案
06-30
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。这个“leetcode答案-LeetCode:力扣答案”很可能是某位开发者或学习者整理的LeetCode问题解决方案集合，主要语言是Java...
判断链表是否为回文链表leetcode-LeetCode:力扣解决方案
07-01
判断链表是否为回文链表 leetcode 力码 分而治之 划分：将问题分解为更小的子问题。 采用递归方法进行除法，直到没有子问题可以进一步除法为止。 征服：子问题被认为是自己解决的。 合并：递归地合并子问题，直到...
力扣考研经典题 反转链表
qq_55751640的博客
07-07 703
头插法： 不断的将cur指针所指向的节点放到头节点之前，然后头节点指向cur节点，因为最后返回的是head.next。
leetcode--从中序与后序遍历序列构造二叉树
最新发布
liulanba的博客
07-09 496
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
力扣双指针算法题目：快乐数
m0_73426459的博客
07-07 333
由图可知，这是一个有环链表，说起链表问题，在判断一个链表是否有环的时候，我们常用的思想就是快慢指针思想，通常来讲就是有两个指针slow和fast，slow初始化在第一个位置，fast初始化在第二个位置，slow一次走一格，fast一次走两格，如果slow指针可以和fast指针相遇，那么就说明这个链表是有环的。如何让快指针dfast每次推进两个格子，我们只要将fast目前所代表的数字调用一下bitsum得到它后面的一个数字，再让它后面的一格数字再次调用一下bitsum就可以了，这便是如下的代码。
Leetcode 3209. Number of Subarrays With AND Value of K
codename_cys的博客
07-07 638
Leetcode 3209. Number of Subarrays With AND Value of K
力扣刷题集-更新至链表
06-21
力扣刷题集-更新至链表

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值