王道数据结构代码笔记

最新推荐文章于 2024-08-29 23:51:27 发布
最新推荐文章于 2024-08-29 23:51:27 发布
阅读量3.4k 收藏 87
点赞数 7
分类专栏： 考研笔记 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35653247/article/details/125811727
版权
本文详细介绍了数据结构的基础知识，包括数据结构的逻辑结构和存储结构，以及算法的效率度量。接着深入讲解了线性表的各种实现，如顺序表、单链表、双链表、循环链表和静态链表的操作。此外，还涵盖了栈、队列的实现，包括顺序栈、共享栈、链栈和循环队列。最后，文章提到了树与二叉树的概念，如二叉树的遍历和线索二叉树，并简单提及了图的存储结构和查找算法，如二叉排序树和平衡树AVL。
摘要由CSDN通过智能技术生成

知识点

1 绪论

1.1 数据结构的基本概念

1.1.1 基本概念和术语

数据：信息的载体

数据元素：数据的基本单位(整体考虑)，由若干数据项（不可分割）组成。组合项：年月日等。

数据对象：具有相同性质的元素的集合，是数据的子集（性质相同：账号的集合）

数据结构：互相存在一种或多种特定关系的元素的集合（存在关系：财富排行榜）

数据类型

1.1.2 数据结构的三要素

逻辑结构独立于存储结构，存储结构依赖于逻辑结构

逻辑结构：集合、线性结构（一对一）、树形结构（一对多）、图状结构或网状结构（多对多）
存储结构
描述 优点 缺点
顺序存储 逻辑相邻物理也相邻 随机存取
每个元素占用最少的空间		 产生外部碎片
链式存储 不要求逻辑上相邻即物理相邻 不会产生碎片，充分利用存储空间 指针占用额外空间
只能顺序存取
索引存储 建立索引表(索引项) 检索速度快 索引表额外占用空间
修改索引表耗时
散列存储 根据关键字直接算出地址，又称哈希存储 检索、增加、删除节点都很快 散列函数不好时增加开销
运算

运算的__定义__是针对逻辑结构的，运算的实现是针对存储结构的。

1.2 算法和算法评价

1.2.1 算法的基本概念

算法是对特定问题求解步骤的描述，是指令的有限序列。

算法(有穷) <> 程序(无穷，微信可以一直运行)

程序 = 算法 + 数据结构 （算法独立于数据结构）

软件 = 程序 + 数据 + 文档

算法的特性：有穷性、确定性、可行性、输入、输出。

好的算法：正确性、可读性、健壮性、效率与低存储量需求

1.2.2 算法效率的度量

时间复杂度

空间复杂度

第二章 线性表

顺序表

SqList

//顺序表静态分配
#define MAxSize 50
typedef struct{
   
    ElemType data[MaxSize];
    int length;
}SqList;

void InitList(SqList &L)

//顺序表静态分配的初始化
void InitList(SqList &L){
   
    L.length=0;
}

SeqList

void InitList(SeqList &L)

void IncreaseSize(SeqList &L,int len)

//顺序表动态分配
#define InitSize 50
typedef struct{
    ElemType *data;
    int MaxSize,length;
}SeqList;

//顺序表动态分配的初始化
#define InitSize 10
void InitList(SeqList &L){
   
    L.data=(ElemType*)malloc(InitSize*sizeof(ElemType));
    L.length=0;
    L.MaxSize=InitSize;
}

//扩展动态数组
void IncreaseSize(SeqList &L,int len){
   
    int *p=L.data;//保存原指针
    L.data=(ElemType*)malloc((L.MaxSize + len) * sizeof(ElemType));
    for(int i=0; i<L.length; i++)//循环复制
    	L.data[i] = p[i];
    L.MaxSize += len;	//Size变大但len不变
    free(p);			//释放
}

int main(){
   
    SeqList L;//定义
    InitList(L);//初始化
    //..添加...
    IncreaseSize(L, 5);//扩展
    return 0;
}

bool ListInsert(SqList &L,int i,ElemType e)

//在位序为i的位置插入元素e
bool ListInsert(SqList &L,int i,ElemType e){
   
    if(i<1 || i>L.length + 1)		//判断位序合法
        return false;// i可以等于length+1(插在末尾)
    if(L.length>=MaxSize)			//判断空间没满
        return false;
   for(int j = L.length; j>=i; j--)
       L.data[j] = L.data[j-1];		//移动元素
    L.data[i-1]  = e;
    L.length++;					//长度++
    return true;
}

bool ListDelete(SqList &L,int i,ElemType &e)

//删除位序为i的元素，赋值给e
bool ListDelete(SqList &L,int i,ElemType &e){
   
    if(i<1 || i>L.length)			//判断位序合法
    	return false;
    e = L.data[i-1];				//赋值
    for(int j=i; j<L.length; j++)	//移动
        L.data[j-1] = L.data[j];
    L.length--;
    //长度--
    return true;
}

int LocateElem(SqList L,ElemType e)

//按值查找，返回位序
int LocateElem(SqList L,ElemType e){
   
    int i;
    for(i=0; i<L.length; i++)
        if(L.data[i] == e)return i+1;
    return 0;
}

ElemType GetElem(SqList L,int i)

ElemType GetElem(SqList L,int i){
   //按位查找，返回值
    if(i<1 || i>L.length)return false;	//判断合法
    return L.data[i-1];
}

单链表(带头结点)

LNode,*LinkList

typedef struct LNode{
   
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

bool InitList(LinkList &L)

//不带头结点
bool InitList(LinkList &L){
   
    L=NULL;
    return true;
}

//带头结点：
bool InitList(LinkList &L){
   //头结点不需要在main函数中分配
    L=(LNode*)malloc(sizeof(LNode));	//头结点
    if(L==NULL)return false;			//分配失败
    L->next=NULL;
    return true;
}

bool Empty(LinkList L)

bool Empty(LinkList L){
   
    return (L==NULL);//不带头结点
    return (L->next==NULL);//带头结点
}

LinkList List_HeadInsert(LinkList &L)

//头插法
LinkList List_HeadInsert(LinkList &L){
   
    LNode *s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));	//头结点
    L->next=NULL;//头指针
    scanf("%d", &x);
    while(x!=9999){
   
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d", &x);
    }
    return L;
}

LinkList List_TailInsert(LinkList &L)

//带头结点
LinkList List_TailInsert(LinkList &L){
   
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s, *r=L;//尾指针
    scanf("%d",&x);
    while(x!=9999){
   
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;//置尾指针
    return L;
}

LNode *GetElem(LinkList L,int i)

//返回位序为i的节点的指针
LNode *GetElem(LinkList L,int i){
   
    int j = 1;
    LNode *p = L->next;
    //若为头结点，直接返回L
    if(i==0)return L;
    //小于0，不合法，返回NULL
    if(i<1)return NULL;
    //计数同时判非空，返回
    while(p!=NULL && j<i){
   
        p = p->next;
        j++;
    }
    return p;
}

LNode *LocateElem(LinkList L,ElemType e)

LNode *LocateElem(LinkList L,ElemType e){
   
    //判值同时判非空
}

bool ListInsert(LinkList &L,int i,ElemType e)

//按位序插入(调用)
bool ListInsert(LinkList &L,int i,ElemType e){
   //在位序i处插入e
    if(i<1)return false;
    LNode *p = GetElem(L,i-1);//找到前一个结点（若在不带头结点的链表的首部插入，需单独讨论）
    return InsertNextNode(p,e);//后插
}



//按位序插入(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
   
    if(i<1)return false;//最小插入位置为1(位序)
    LNode *p;
    int j = 0;//第几个节点
    p = L;//遍历
    while(p!=NULL && j<i-1){
   //位序为i，则下标为i-1
        p = p->next;
        j++;
    }
    if(p==NULL)return false;//退出循环的原因是链表到头了
    LNode *s = (LNode*)malloc(sizeof(LNode));	//新节点
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

//按位序插入(不带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
   
    if(i<1)return false;
    if(i==1){
   //在首部插入单独考虑(操作不同)
        LNode *s = (LNode*)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;	//这两行操作不同
        L = s;			//这两行操作不同
        return true;
    }
    LNode *p;
    int j = 1;//最开始就是第一个节点
    p = L;
    while(p!=NULL && j<i-1){
   
        p = p->next;
        j++;
    }
    if(p==NULL)return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

bool ListDelete(LinkList &L,int i,ElemType &e)

//删除位序i(带头结点)
bool ListDelete(LinkList &L,int i,ElemType &e){
   
    if(i<1)return false;
    LNode *p;
    int j = 0;
    p = L;
    while(p!=NULL && j<i-1){
   
        p = p->next;
       j++;
    }
    if(p==NULL)return false;//i非法
	LNode *q=p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//指定节点的删除(赋值后删后节点)
bool DeleteNode(LNode *p){
   
    if(p==NULL)return false;
    LNode *q = p->next;
    p->data = p->next->data;//************************p->next可能为空(p为尾结点)*******
    p->next = q->next;
    free(q);
    return true;
}

bool InsertNextNode(LNode *p,ElemType e)

bool InsertPriorNode(LNode *p,ElemType e)

bool InsertNextNode(LNode *p,ElemType e){
   
    if(p==NULL)return false;
    LNode *s = (LNode*)
最低0.47元/天 解锁文章
不归路___
关注
专栏目录
数据结构学习笔记（王道）
qq_55593227的博客
03-19 4万+
数据结构学习笔记（王道） PS：本文章部分内容参考自王道考研数据结构笔记 文章目录数据结构学习笔记（王道）一、绪论1.1. 数据结构1.2. 算法1.2.1. 算法的基本概念1.2.2. 算法的时间复杂度1.2.3. 算法的空间复杂度二、线性表2.1. 线性表的定义和操作2.1.1. 线性表的基本概念2.1.2. 线性表的基本操作2.2. 顺序表2.2.1. 顺序表的基本概念2.2.2. 顺序表的实现2.2.3. 顺序表的基本操作2.3. 链表2.3.1. 单链表的基本概念2.3.2. 单链表的实现2.3.
王道数据结构笔记
weixin_44582953的博客
03-23 3617
王道数据结构笔记2.2 线性表的顺序表示顺序表的实现——动态分配顺序表的特点总结 2.2 线性表的顺序表示 顺序表的实现——动态分配 由于需要将数据复制到新的区域因此时间开销大 #include <stblib.h> #define InitSize 10 //默认最大长度 typedef struct{ int *data; //指示动态分配数组的指针 int MaxSize; //顺序表的最大容量 int length; //顺序表的当前长度 }SeqList; void In
王道数据结构总结1
08-04
第一章绪论1.1时间复杂度的求法（一）循环主体中的变量参与循环条件的判断a) 找出基本操作b) 设基本操作执行次数为 T(n)，根据初始条件和基本操作语句确定变
25版王道数据结构课后习题详细分析 第六章图 6.1图的基本概念
最新发布
2406_86301373的博客
08-29 979
01.图中有关路径的定义是()。 02.一个有n个顶点和n条边的无向图一定是()。 03.若从无向图的任意顶点出发进行一次深度优先搜索即可访问所有顶点，则该图一定04.以下关于图的叙述中，正确的是()。 05.以下关于图的叙述中，正确的是()。 06.一个有28条边的非连通无向图至少有( )个顶点。 07.对于一个有n个顶点的图：若是连通无向图，其边的个数至少为( );若是强连通有向图则其边的个数至少为( )。
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 23万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
王道2023数据结构笔记
一顿吃不饱的博客
07-15 1万+
线性表的定义​线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=(a1,a2,…,ai,ai+1,…,an)​ai是线性表中的“第i个”元素线性表中的位序​a1是表头元素；an是表尾元素​除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继线性表的基本操作初始化表。构造一个空的线性表L，分配内存空间。销毁操作。插入操作。删除操作。...
数据结构（王道计算机考研笔记）
weixin_49393290的博客
09-13 8915
数据结构
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
《王道》数据结构代码实现与笔记
qq_34060370的博客
03-21 7295
陆续更新至2022年12月底。 这篇Blog，简单的做个学王道数据结构的笔记，为了以后能快速回顾，笔记做得不好，见谅。 文章目录一、线性表1.顺序表的顺序表示1.1顺序表-静态数组1.2顺序表-动态数组2.顺序表的链式表示2.1单链表-带头结点2.2单链表-不带头结点 一、线性表 1.顺序表的顺序表示 1.1顺序表-静态数组 静态分配，大小不可改变 #include <stdio.h> #define MaxSize 10 // 定义最大长度 typedef struct { int
王道考研数据结构笔记
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
王道计算机408数据结构 笔记1
Scott_wuu的博客
06-25 647
1.1.0 数据结构在学什么 1.1.1 数据结构的基本概念 1.2.1 算法的基本概念
《数据结构》（学习笔记）（王道）
qiqi_liuliu的博客
04-23 3177
Personal study notes, please point out any errors, thank you!
【王道考研】王道数据结构与算法详细笔记（全）
强哥的微博
06-08 3万+
线性表是具有相同数据类型的n(n>0)个数据元素的有限序列。(其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为)1. 存在惟一的第一个元素。2. 存在惟一的最后一个元素。3. 除第一个元素之外，每个元素均只有一个直接前驱。4. 除最后一个元素之外，每个元素均只有一个直接后继1.是线性表中的“第i个”元素线性表中的位序。2.是表头元素;是表尾元素。
王道论坛机试指南学习笔记（二）数据结构
qq_42290765的博客
05-06 1166
文章目录1. 栈- 基本用法- 括号匹配- 四则运算器2. 优先队列- 基本用法- 哈夫曼树3. 二叉树- 数据结构- 前序遍历- 中序遍历- 后序遍历- 根据前中序生成二叉树4. 二叉排序树- 插入5. 列表List- 定义- 函数 1. 栈 - 基本用法 声明 //栈的元素类型必须是Object的子类 //如Integer, Boolean，不可以是int, boolean等 Stack&...
数据结构-王道-图
weixin_33857679的博客
09-21 2186
目录 图的基本概念 图的遍历 图的应用 最短路径 拓扑排序 关键路径 图的基本概念 图\(G\)由顶点集\(V\)和边集\(E\)组成，记为\(G=(V,E)\)，其中\(V(G)\)表示图\(G\)中顶...
王道考研-数据结构笔记
09-16
"王道数据结构笔记"可能涵盖了这些基础知识，以及更高级的主题，如图论、动态规划、贪婪算法等。通过阅读和研究这份笔记，考生可以系统地梳理数据结构的知识体系，提高解决问题的能力，为考研做好充分准备。在复习...
数据结构笔记--王道
魔芋小灰菜
05-16 225
数据结构笔记–王道-2021年3月
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值