5.17——day6——计科大一0基础面向工作式学习

于 2025-05-17 18:00:39 发布
阅读量1k 收藏 20
点赞数 33
文章标签： c++ 算法 学习 代码随想录 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86536479/article/details/148019431
版权

学习概要

代码随想录

        数组

                9.总结篇

                主要方法：

                （1）.二分法（注意循环不变量，保持开闭不变）

                （2）.双指针法

                （3）.滑动窗口

                （4）.前缀和

                （5）.模拟法

                此部分学习完数组部分也告一段落了，但是仍需注意复习。复习的方法是先将题目拿出来自己先写一遍AC，再快速浏览一遍代码随想录文字版说明。

代码随想录：链表

        1.链表理论基础

        知识点：

        （1）.链表的定义

        

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

有同学说了，我不定义构造函数行不行，答案是可以的，C++默认生成一个构造函数。

但是这个构造函数不会初始化任何成员变量，下面我来举两个例子：

通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

删除节点

删除D节点，如图所示：

链表-删除节点

只要将C节点的next指针 指向E节点就可以了。

那有同学说了，D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。

是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

#添加节点

如图所示：

链表-添加节点

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

#性能分析

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。

        2.移除链表元素leetcode’203

        注意：还要说明一下，就算使用C++来做leetcode，如果移除一个节点之后，没有手动在内存中删除这个节点，leetcode依然也是可以通过的，只不过，内存使用的空间大一些而已，但建议依然要养成手动清理内存的习惯。

        独立AC，但是编译错误删删改改好多次，虽然都是小错误。没有系统写这个问题的能力，要靠编译系统的提示来完成这个题目。

        系统代码要点：

        (1).        设置虚拟头节点，使得所有代码执行相同的删除操作（注意，最后返回虚拟头节点的next）

法一：直接使用原来的链表操作，并且通过cur->next->val来访问元素达到方便删除的操作

  • 时间复杂度: O(n)
  • 空间复杂度: O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头结点
        ListNode* cur = head;
        while (cur != NULL && cur->next!= NULL) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

法二：直接使用原来的链表操作，但是设置一个前置节点，通过p->val来访问，达到删除节点的目的

  • 时间复杂度: O(n)
  • 空间复杂度: O(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) {
        while(head!=NULL&&head->val==val){
            ListNode* tmp = head;
            head=head->next;
            delete tmp;
        }
        if(head==NULL){return head;}

        else{
            ListNode *p=head;
            ListNode *pre;
            while(p!=NULL)
            {
                while(p!=NULL&&p->val!=val){ 
                    pre=p;
                    p=p->next;
                }
                if(p!=NULL){
                     ListNode* tmp = p;
                     pre->next=p->next;
                     p=p->next;
                     delete tmp;
                }
            }
            return head;
        }
    }
};

法三：设置虚拟头节点:注意设置虚拟头节点的时候的代码实现

  • 时间复杂度: O(n)
  • 空间复杂度: O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        ListNode * v_head=new ListNode(-1,head);//开辟一个空间，正确的
        //ListNode *v_head ;/*只定义了一个指向ListNode的指针，会被系统自动初始化为nullptr,导致下一句语句出错*/
        //v_head->next=head;
        ListNode *p=head;
        ListNode *pre=v_head;

        while(p!=NULL)
        {
            while(p!=NULL&&p->val!=val){
                pre=p;
                p=p->next;
            }

            if(p!=NULL){
                ListNode* tmp=p;
                pre->next=p->next;
                p=p->next;
                delete tmp;
            }

        }
            return v_head->next;
    }
};

法四：递归

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

注意点：递归的逻辑，以及处理，非常不熟悉，递归调用的掌握很差，要多加练习。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        if(head==nullptr){
            return nullptr;
        }

        else{
            if(head->val==val){
                ListNode *new_head=removeElements(head->next, val);
                delete head;
                return new_head;
            }
            /*else if(head->val!=val){
                head->next=removeElements(head->next,val);
                return head;
            }*/
 /*错误原因
编译器可能没有正确推断出 else 块中的 if 和 else if 分支已经覆盖了所有可能的情况。虽然逻辑上是正确的，但编译器可能认为存在一个路径没有返回值。
解决方法
为了确保编译器能够正确推断出所有路径都有返回值，可以简化代码结构，去掉不必要的 else 块，并确保每个分支都有明确的返回值。
*/
            else {
                head->next=removeElements(head->next,val);
                return head;
            }
        }
    }
};

        3.设计链表leetcode‘707

        作为链表中知识点较为全面的题，虽然成功AC但是借助了AI帮我翻译了许多编译错误的提示，还是要学会自己看编译错误的提示！！！！！

        要点：注意结构体ListNode的定义结尾要加分号，在该结构体中定义一个类似构造函数的来初始化结构体ListNode；本题中不加分号会出现一个奇怪的编译错误的提示，有关作用域什么的，有点奇怪；

对于void类型函数的话要提前结束可以直接使用return；

还有获取，删，插入都要判断index与size的关系

使用虚拟头节点将所有代码的逻辑统一，减少分类讨论

在插入节点的时候一定要注意两条边的顺序，顺序错误会导致插入失败

AC代码

class MyLinkedList {
public:
    struct ListNode
    {
        int val;
        ListNode * next;
        ListNode(int val) :val(val),next(nullptr){}
    };//结尾要加分号，不然会编译错误，但是出现的提升有点奇怪？？
    
    MyLinkedList() {
        v_head=new ListNode(0);
        size=0;
    }
    
    int get(int index) {
        if(index<0||index>size-1)
        {
            return -1;
        }
        else{
            ListNode *cur=v_head->next;
            for(int i=0;i<index;i++)
            {
               cur=cur->next;
            }
            return cur->val;
        }
    }
    
    void addAtHead(int val) {
        ListNode *p=new ListNode(val);
        p->next=v_head->next;
        v_head->next=p;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode *p=new ListNode(val);
        ListNode *cur=v_head;
        while(cur->next!=nullptr)
        {
            cur=cur->next;
        }
        cur->next=p;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<0||index>size){
            return;
        }
        ListNode *p=new ListNode(val);
        ListNode *cur=v_head;
        for(int i=0;i<index;i++)
        {
            cur=cur->next;
        }
        p->next=cur->next;
        cur->next=p;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>size-1){
            return ;
        }
        ListNode *cur=v_head;
        for(int i=0;i<index;i++)
        {
            cur=cur->next;
        }
        ListNode *p=cur->next;
        cur->next=cur->next->next;
        delete p;
        size--;
    }
    private:
    int size;
    ListNode *v_head;
};

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

cimo_1
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值