线性表（链式存储）

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量248 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c# c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53581996/article/details/127397337
版权
线性表（链式存储）
摘要由CSDN通过智能技术生成

一、单链表的初始化

//单链表的初始化（不带头结点）
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = NULL;      //空表，暂时没有任何结点
    return true;
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    return 0;
}

//单链表的初始化（带头结点）
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    return 0;
}

二、单链表的插入

//单链表的按位序插入(带头结点)
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);     //插入
    return 0;
}

//单链表的按位序插入(不带头结点)
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （不带头结点）
bool ListInsert(LinkList &L,int i,int e){
    if(i<1) return false;
    if(i==1){              //插入第1个结点的操作与其他结点操作不同
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;         //头指针指向新结点
        return true;
    }
    LNode *p;            //指针p指向当前扫描到的结点
    int j=1;         //当前p指向的是第几个结点
    p=L;           //p指向第一个结点，不是头结点
    while(p!=NULL&&j<i-1){           //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;           //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;            //插入成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);     //插入
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    return 0;
}

//单链表指定结点的后插 
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;

 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//在p结点之后插入元素e
bool InsertNextNode(LNode *p, int e){
    if(p==NULL) return false;     //p结点不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL) return false;     //内存分配失败 
    s->data = e;      //用结点s保存数据元素e 
    s->next=p->next;
    p->next=s;       //将结点s连到p之后 
    return true;     //插入成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,10);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    LNode *t=L->next;
    InsertNextNode(t,11);     //后插
    //打印数据
    L=L->next;
    while(L!=NULL){
        printf("%d\n",L->data);
        L=L->next;
    }
    return 0;
}

//单链表指定结点的前插 
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;

 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//在p结点之前插入元素e
bool InsertPriorNode(LNode *p, int e){
    if(p==NULL) return false;     //p结点不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL) return false;     //内存分配失败 
    s->next=p->next;
    p->next=s;        //新结点s连到p之后 
    s->data=p->data;       //将p中元素复制到s中 
    p->data=e;          //p中元素覆盖为e 
    return true;     //插入成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    LNode *t=L->next;
    InsertPriorNode(t,10);     //前插
    //打印数据
    L=L->next;
    while(L!=NULL){
        printf("%d\n",L->data);
        L=L->next;
    }
    return 0;
}

三、单链表的删除

//单链表按位序删除
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//在第i个位置删除元素e
bool ListDelete(LinkList &L, int i, int &e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    if(p->next==NULL) return false;     //i-1个结点之后已无其他结点
    LNode *q=p->next;          //令q指向被删除的结点
    e=q->data;        //用e返回元素的值
    p->next=q->next;
    free(q);       //释放结点存储空间
    return true;     //删除成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    int e=0;
    ListDelete(L,1,e);    //删除
    printf("%d\n",e);
    //打印数据
    L=L->next;
    while(L!=NULL){
        printf("%d\n",L->data);
        L=L->next;
    }
    return 0;
}

//单链表按指定结点删除
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//删除指定结点p
bool DeleteNode(LNode *p){
    if(p==NULL) return false;     //结点p不合法
    if(p->next==NULL) return false;     //p结点之后已无其他结点
    LNode *q=p->next;          //令q指向p结点的后继结点
    p->data=q->data;            //和后继结点交换数据域
    p->next=q->next;              
    free(q);       //释放后继结点的存储空间
    return true;     //删除成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    LNode *t=L->next;
    DeleteNode(t);    //删除
    //打印数据
    L=L->next;
    while(L!=NULL){
        printf("%d\n",L->data);
        L=L->next;
    }
    return 0;
}

四、单链表的查找

//单链表的按位查找
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//按位查找，返回第i个元素的值
bool GetElem(LinkList L, int i, int &e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i){     //循环找到第i个结点
        p=p->next;
        j++;
    }
    e=p->data;         //p结点的值赋给e，返回
    return true;     //查找成功
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    int e=0;
    GetElem(L,4,e);    //查找
    printf("%d\n",e);         //打印数据
    return 0;
}

//单链表的按值查找
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//按值查找，找到数据域==e的结点
LNode * LocateElem(LinkList L, int e){
    LNode *p=L->next;       //从第一个结点开始查找数据域为e的结点
    while(p!=NULL && p->data!=e){
        p=p->next;
    }
    return p;     //找到后返回该结点的指针，否则返回NULL
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    LNode *t=LocateElem(L,14);    //查找
    int e=t->data;
    printf("%d\n",e);    //打印数据
    return 0;
}

五、求单链表的长度

//求单链表的长度
#include <stdio.h>
#include <stdlib.h>    //malloc、free函数的头文件
typedef struct LNode{    //定义单链表结点类型
    int data;          //每个结点存放一个数据元素
    struct LNode *next;      //指针指向下一个结点
}LNode,*LinkList;
 
 //初始化单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L == NULL) return false;      //内存不足分配失败
    L->next=NULL;           // 头结点之后暂时还没有结点
    return true;
}

//在第i个位置插入元素e （带头结点）
bool ListInsert(LinkList &L, int i, int e){
    if(i<1) return false;     //i值不合法
    LNode *p;    //指针p，指向当前扫描到的结点
    int j=0;     //当前p指向的是第几个结点
    p = L;       //L指向头结点
    while(p!=NULL && j<i-1){     //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL) return false;     //i值不合法
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next=s;       //将结点s连到p之后
    return true;     //插入成功
}

//求单链表的长度
int Length(LinkList L){
    int len = 0;      //统计表长
    LNode *p=L;
    while (p->next != NULL){
        p=p->next;
        len++;
    }
    return len;
}

int main(){
    LinkList L;        //声明一个单链表的指针
    InitList(L);     //初始化单链表
    ListInsert(L,1,11);
    ListInsert(L,2,12);
    ListInsert(L,3,13);
    ListInsert(L,4,14);
    int e=Length(L);
    printf("%d\n",e);
    return 0;
}

舞弄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式存储_线性表的链式存储_
10-02
在数据结构领域，线性表的实现方式主要有两种：顺序存储和链式存储。本套资料专注于线性表的链式存储在Windows C++环境下的实现。 链式存储是一种非连续的存储方式，与顺序存储相比，它更加灵活，因为元素之间的...
线性表之链式存储效果展示
06-29
本资源为线性表的链式存储演示效果可执行文件，欢迎下载欣赏。源码请关注公众号“多米学算法”下载。希望能够帮助到你
线性表的链式存储结构..
07-11
实验二 线性表的链式存储结构 题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。1. 用户可以根据自己的需求...
线性表的链式存储与实现
07-29
在链式存储的线性表中，主要有单链表和双向链表两种形式： 1. 单链表：每个节点只有一个指向下一个节点的指针，最后一个节点的指针为空，表示链表的结束。单链表的插入和删除操作相对简单，只需要修改相邻节点的...
线性表的链式存储和实现
12-22
若涉及插入、删除较多的话，则宜用链式存储；具体选择哪一种存储结构要根据需要进行的操作来分析。 　下面分享链式存储实现的代码，希望对你的学习有帮助 　// 测试.cpp : 定义控制台应用程序的入口点。 　// 　...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 629
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 327
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
c语言（7.23）
fhgfyrsg的博客
07-23 531
【代码】c语言（7.23）
数据结构：逻辑结构与物理结构
Weiki的博客
07-24 942
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 753
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 418
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
【数据结构】顺序表（c语言实现）（附源码）
2301_80955819的博客
07-24 841
顺序表的概念和结构，顺序表的分类，顺序表的功能实现
【数据结构】二叉树——顺序结构——堆及其实现
LH__1314的博客
07-23 1050
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成的一个具有层次关系的集合。除根节点外，其余部分被分为M（M>0）个互不相交的集合T1、T2、.....Tm，其中的每一个集合 Ti（1 <= i <= m）又是一颗结构与数类似的子树。每一颗子树的根节点都有且只有一个前驱节点，而可以有0个或者多个后继节点。树是递归定义的。在树形结构中，子树之间不能存在交集子树中存在交集，就不是树形结构了除了根节点以外，每一个节点有且只有一个父节点如图，E节点存在两个父节点，该图不是树形结构。
数据结构——二叉树定义
鲸落博客
07-23 423
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
json的数据结构
qq_46396470的博客
07-24 726
括起来的字符串（String）、数值(Number)、布尔值(true/false)、 null、对象（Object）或者数组（Array），这些结构可以嵌套。JSON 和 XML都是常用的数据交换格式。它们之间有什么区别呢？可以看到，JSON 比 XML 更加简洁，没有了冗余的标签和属性。数组（array）是值（value）的有序集合。，对应的值是字符串、数字和字符串。值（value）可以是花括号。JSON 字符串是由双引号。在这个例子中，对象的键是。在这个例子中，字符串。在这个例子中，布尔值。
java常用8大排序
zzp1224的博客
07-24 653
Java中的八大排序算法是编程中常用的排序方法，每种排序算法都有其独特的特点和应用场景。
学习记录——day17 数据结构 队列 链式队列
weixin_64918301的博客
07-23 463
1、队列也是操作受限的线性表:所有操作只能在端点处进行，其删除和插入必须在不同端进行2、允许插入操作的一端称为队尾，允许删除操作的一端称为队头3、特点:先进先出(FIFO)4、分类：顺序存储的栈称为顺序栈链式存储的队列，称为链式队列。
2024.7.24 作业
qq_64434282的博客
07-24 1224
【代码】2024.7.24 作业。
学习记录——day17 数据结构 树
weixin_64918301的博客
07-23 350
指向非法内存的指针产生的情况有：未初始化随进程的进行原本指向的内存被释放了数组下标越界函数返回的是生命周期较短的变量，返回时内存被释放了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值