数据结构中有向图和无向图的C语言实现
算法与数据结构课设(有向图,无向图,有向网,无向网)
算法与数据结构课程设计报告系(院):计算机科学学院专业班级:教技1001姓名:李##学号: ******### 指导教师:***设计时间:2012.6.16 - 2012.6.24设计地点:4号楼2号机房目录一、设计方案 (1)二、实现过程以及代码 (2)三、测试 (20)四、结论和分析 (23)五、难点和收获 (23)一、 设计方案1.程序设计基本过程:拿到课程设计任务书,按照要求,需要设计有向图、有向网、无向图 、无向网四种图,以及邻接矩阵、邻接表两种数据存储结构,三层以上的显示菜单。
图的操作中又包含了有关线性表、栈和队列的基本操作。
由于显示菜单已给出,剩下的任务就是把函数写入其中。
2.程序流程图:预定义 定义结构体 定义变量 各种函数3.程序设计的原理:图的操作都是以两种存储结构为基础的:邻接矩阵存储结构和邻接表存储结构,如有向图,有向网,无向图,无向网的创建,其他的操作都是在四种图创建后才开始进行的。
所以,首先必须理解两种存储结构的定义。
图的邻接矩阵存储结构即图的数组表示法。
用两个数组分别存储数据元素(如顶点)的信息和数据元素之间的关系(如边或弧)的信息。
用邻接矩阵存储结构的图具有以下几点特征:(一):顶点数:vexnum ,边(弧)数:arcnum ,图的种类:kind ;(二):邻接矩阵:arcs(1顶点关系类型:adj 2相关信息:*info);(三):顶点向量(顶点名):vexs[];其优点是以二维数组表示有n 个顶点的图时,需存放n 个顶点的信息和n*n 条弧的信息存储量。
借助邻接矩阵容易判定任意两个顶点之间是否有边或弧相连,并容易求出各个顶点的度。
缺点是时间复杂度是O (n*n ),例如,构造一个具有n 个顶点和e 条边的无向网的时间复杂度为O (n*n+e*n )。
图的邻接表存储结构是图的一种链式存储结构。
对图中的每个顶点建立一个单链表,每个结点由三个域组成,邻接点域adjvex (弧尾在邻接表链表中的位序),链域nextarc (下一条弧),数据域info(权值)。
数据结构(C语言版)
比较
Prim算法适用于稠密图, Kruskal算法适用于稀疏图;
两者时间复杂度相近,但 Kruskal算法需额外处理并查
集数据结构。
最短路径算法设计思想及实现方法比较
1 2
Dijkstra算法
从源点出发,每次找到距离源点最近的顶点并更 新距离值,直至所有顶点距离确定。适用于不含 负权边的图。
Floyd算法
特殊二叉树
满二叉树、完全二叉树等。
二叉树的遍历与线索化
二叉树的遍历
前序遍历、中序遍历、后序遍历和层 次遍历是二叉树的四种基本遍历方法 。
线索化二叉树
为了方便查找二叉树节点的前驱和后 继,可以对二叉树进行线索化处理, 即在节点的空指针域中存放指向前驱 或后继的指针。
树和森林的遍历与转换
树的遍历
01
串的顺序存储结构
01
02
03
串的顺序存储结构是用 一组地址连续的存储单 元来存储串中的字符序
列的。
按照预定义的大小,为 每个定义的串变量分配 一个固定长度的存储区 ,一般是用定长数组来
定义。
串值的存储:将实际串 长度值保存在数组的0下 标位置,串的字符序列 依次存放在从1开始的数
组元素中。
串的链式存储结构
03
比较
DFS空间复杂度较低,适用于递 归实现;BFS可找到最短路径, 适用于非递归实现。
最小生成树算法设计思想及实现方法比较
Prim算法
从某一顶点开始,每次选择当 前生成树与外界最近的边加入 生成树中,直至所有顶点加入
。
Kruskal算法
按边权值从小到大排序,依次 选择边加入生成树中,保证不
形成环路。
数据结构(C语言版)
《数据结构(C语言版 第2版)》(严蔚敏 著)第六章练习题答案
《数据结构(C语言版第2版)》(严蔚敏著)第六章练习题答案第6章图1.选择题(1)在一个图中,所有顶点的度数之和等于图的边数的()倍。
A.1/2B.1C.2D.4答案:C(2)在一个有向图中,所有顶点的入度之和等于所有顶点的出度之和的()倍。
A.1/2B.1C.2D.4答案:B解释:有向图所有顶点入度之和等于所有顶点出度之和。
(3)具有n个顶点的有向图最多有()条边。
A.n B.n(n-1)C.n(n+1)D.n2答案:B解释:有向图的边有方向之分,即为从n个顶点中选取2个顶点有序排列,结果为n(n-1)。
(4)n个顶点的连通图用邻接距阵表示时,该距阵至少有()个非零元素。
A.n B.2(n-1)C.n/2D.n2答案:B所谓连通图一定是无向图,有向的叫做强连通图连通n个顶点,至少只需要n-1条边就可以了,或者说就是生成树由于无向图的每条边同时关联两个顶点,因此邻接矩阵中每条边被存储了两次(也就是说是对称矩阵),因此至少有2(n-1)个非零元素(5)G是一个非连通无向图,共有28条边,则该图至少有()个顶点。
A.7B.8C.9D.10答案:C解释:8个顶点的无向图最多有8*7/2=28条边,再添加一个点即构成非连通无向图,故至少有9个顶点。
(6)若从无向图的任意一个顶点出发进行一次深度优先搜索可以访问图中所有的顶点,则该图一定是()图。
A.非连通B.连通C.强连通D.有向答案:B解释:即从该无向图任意一个顶点出发有到各个顶点的路径,所以该无向图是连通图。
(7)下面()算法适合构造一个稠密图G的最小生成树。
A.Prim算法B.Kruskal算法C.Floyd算法D.Dijkstra算法答案:A解释:Prim算法适合构造一个稠密图G的最小生成树,Kruskal算法适合构造一个稀疏图G的最小生成树。
(8)用邻接表表示图进行广度优先遍历时,通常借助()来实现算法。
A.栈 B.队列 C.树D.图答案:B解释:广度优先遍历通常借助队列来实现算法,深度优先遍历通常借助栈来实现算法。
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务:给定⼀个有向图,实现图的深度优先, ⼴度优先遍历算法,拓扑有序序列,并输出相关结果。
功能要求:输⼊图的基本信息,并建⽴图存储结构(有相应提⽰),输出遍历序列,然后进⾏拓扑排序,并测试该图是否为有向⽆环图,并输出拓扑序列。
按照惯例,先上代码,注释超详细:#include<stdio.h>#include<stdlib.h>#include<malloc.h>#pragma warning(disable:4996)#define Max 20//定义数组元素最⼤个数(顶点最⼤个数)typedef struct node//边表结点{int adjvex;//该边所指向结点对应的下标struct node* next;//该边所指向下⼀个结点的指针}eNode;typedef struct headnode//顶点表结点{int in;//顶点⼊度char vertex;//顶点数据eNode* firstedge;//指向第⼀条边的指针,边表头指针}hNode;typedef struct//邻接表(图){hNode adjlist[Max];//以数组的形式存储int n, e;//顶点数,边数}linkG;//以邻接表的存储结构创建图linkG* creat(linkG* g){int i, k;eNode* s;//边表结点int n1, e1;char ch;g = (linkG*)malloc(sizeof(linkG));//申请结点空间printf("请输⼊顶点数和边数:");scanf("%d%d", &n1, &e1);g->n = n1;g->e = e1;printf("顶点数:%d 边数:%d\n", g->n, g->e);printf("请输⼊顶点信息(字母):");getchar();//因为接下来要输⼊字符串,所以getchar⽤于承接上⼀条命令的结束符for (i = 0; i < n1; i++){scanf("%c", &ch);g->adjlist[i].vertex = ch;//获得该顶点数据g->adjlist[i].firstedge = NULL;//第⼀条边设为空}printf("\n打印顶点下标及顶点数据:\n");for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据{printf("顶点下标:%d 顶点数据:%c\n", i, g->adjlist[i].vertex);}getchar();int i1, j1;//相连接的两个顶点序号for (k = 0; k < e1; k++)//建⽴边表{printf("请输⼊对<i,j>(空格分隔):");scanf("%d%d", &i1, &j1);s = (eNode*)malloc(sizeof(eNode));//申请边结点空间s->adjvex = j1;//边所指向结点的位置,下标为j1s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s}return g;//返回指针g}int visited[Max];//标记是否访问void DFS(linkG* g, int i)//深度优先遍历{eNode* p;printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已访问过的顶点visited值改为1p = g->adjlist[i].firstedge;//p指向顶点i的第⼀条边while (p)//p不为NULL时(边存在){if (visited[p->adjvex] != 1)//如果没有被访问DFS(g, p->adjvex);//递归}p = p->next;//p指向下⼀个结点}}void DFSTravel(linkG* g)//遍历⾮连通图{int i;printf("深度优先遍历;\n");//printf("%d\n",g->n);for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问{DFS(g, i);//调⽤DFS函数}}}void BFS(linkG* g, int i)//⼴度优先遍历{int j;eNode* p;int q[Max], front = 0, rear = 0;//建⽴顺序队列⽤来存储,并初始化printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已经访问过的改成1rear = (rear + 1) % Max;//普通顺序队列的话,这⾥是rear++q[rear] = i;//当前顶点(下标)队尾进队while (front != rear)//队列⾮空{front = (front + 1) % Max;//循环队列,顶点出队j = q[front];p = g->adjlist[j].firstedge;//p指向出队顶点j的第⼀条边while (p != NULL){if (visited[p->adjvex] == 0)//如果未被访问{printf("%c ", g->adjlist[p->adjvex].vertex);visited[p->adjvex] = 1;//将该顶点标记数组值改为1rear = (rear + 1) % Max;//循环队列q[rear] = p->adjvex;//该顶点进队}p = p->next;//指向下⼀个结点}}}void BFSTravel(linkG* g)//遍历⾮连通图{int i;printf("⼴度优先遍历:\n");for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问过{BFS(g, i);//调⽤BFS函数}}}//因为拓扑排序要求⼊度为0,所以需要先求出每个顶点的⼊度void inDegree(linkG* g)//求图顶点⼊度{eNode* p;int i;for (i = 0; i < g->n; i++)//循环将顶点⼊度初始化为0{g->adjlist[i].in = 0;}for (i = 0; i < g->n; i++)//循环每个顶点{p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针while (p != NULL)///当p不为空(边存在){g->adjlist[p->adjvex].in++;//该边终点结点⼊度+1p = p->next;//p指向下⼀个边结点}printf("顶点%c的⼊度为:%d\n", g->adjlist[i].vertex, g->adjlist[i].in);}void topo_sort(linkG *g)//拓扑排序{eNode* p;int i, k, gettop;int top = 0;//⽤于栈指针的下标索引int count = 0;//⽤于统计输出顶点的个数int* stack=(int *)malloc(g->n*sizeof(int));//⽤于存储⼊度为0的顶点for (i=0;i<g->n;i++)//第⼀次搜索⼊度为0的顶点{if (g->adjlist[i].in==0){stack[++top] = i;//将⼊度为0的顶点进栈}}while (top!=0)//当栈不为空时{gettop = stack[top--];//出栈,并保存栈顶元素(下标)printf("%c ",g->adjlist[gettop].vertex);count++;//统计顶点//接下来是将邻接点的⼊度减⼀,并判断该点⼊度是否为0p = g->adjlist[gettop].firstedge;//p指向该顶点的第⼀条边的指针while (p)//当p不为空时{k = p->adjvex;//相连接的顶点(下标)g->adjlist[k].in--;//该顶点⼊度减⼀if (g->adjlist[k].in==0){stack[++top] = k;//如果⼊度为0,则进栈}p = p->next;//指向下⼀条边}}if (count<g->n)//如果输出的顶点数少于总顶点数,则表⽰有环{printf("\n有回路!\n");}free(stack);//释放空间}void menu()//菜单{system("cls");//清屏函数printf("************************************************\n");printf("* 1.建⽴图 *\n");printf("* 2.深度优先遍历 *\n");printf("* 3.⼴度优先遍历 *\n");printf("* 4.求出顶点⼊度 *\n");printf("* 5.拓扑排序 *\n");printf("* 6.退出 *\n");printf("************************************************\n");}int main(){linkG* g = NULL;int c;while (1){menu();printf("请选择:");scanf("%d", &c);switch (c){case1:g = creat(g); system("pause");break;case2:DFSTravel(g); system("pause");break;case3:BFSTravel(g); system("pause");break;case4:inDegree(g); system("pause");break;case5:topo_sort(g); system("pause");break;case6:exit(0);break;}}return0;}实验⽤图:运⾏结果:关于深度优先遍历 a.从图中某个顶点v 出发,访问v 。
数据结构C语言
数据结构(C语言)数据组织(数据、数据元素、数据项)的三个层次:数据可由若干个数据元素构成,而数据元素又可以由一个或若干个数据项组成。
四种基本的数据结构:集合、线性结构、树形结构、图状结构。
顺序存储的特点是在内存中开辟一组连续的空间来存放数据,数据元素之间的逻辑关系通过元素在内存中存放的相对位置来确定。
链式存储的特点是通过指针反映数据元素之间的逻辑关系。
数据类型:原子类型、结构类型。
线性表定义:线性表是n个数据元素的有限序列。
线性表的顺序存储结构:表中相邻的元素a和b所对应的存储地址A和B 也是相邻的。
(也就是数据都是按照表中情况进行连续存储的情况)线性表的链式存储结构:该线性表中的数据元素可以用任意的存储单元来存储。
表中的各个相邻的数据(元素)是通过一个指针地址来进行链接的,以找到下一个数据(元素)在哪。
其形式一般为:数据地址线性表的顺序和链式存储结构的比较:在线性表的长度变化比较大,预先难以确定的情况下,最好采用动态链表作为存储结构。
当线性表的长度变化不大时,采用顺序存储结构比较节省存储空间。
在顺序表结构的线性表上主要进行查找、读取而很少做插入和删除的操作。
链式结构的线性表中比较适应做插入和删除的操作。
一元多项式的加减法运算可先将一元多项式进行了改变存储之后再进行运算比较适宜,将一元多项式转换为用在内存中的前一项表示阶数,后一项表示对应该阶数的系数。
然后利用这种形式进行加减运算。
栈和队列栈是限定在表的同一端进行插入或删除操作的线性表,即进栈、出栈。
(特殊的线性表)栈的顺序存储结构:利用一组地址连续的存储单元依次从栈底到栈顶存放数据元素,栈底位置固定不变,可将栈底设在向量低下标的一端。
栈的链式存储结构:用单链表作为存储结构的栈称为链栈,链表的最后一个结点表示栈底,第一个结点表示栈顶。
队列也是一种特殊的线性表。
它所有的插入操作均限定在表的一端进行,而所有的删除操作则限定在表的另一端进行。
允许删除元素的一端称为队头,允许插入元素的一端称为队尾,删除元素称为出队,插入元素称为进队。
数据结构(C语言版) 第1章 绪论
理论课教材: 数据结构(C语言版) 严蔚敏 吴伟民 编著
第一章 绪论
1.0 1.1 1.2 1.3 1.4 学习数据结构的主要意义和要求 数据结构讨论的范畴 基本概念 抽象数据类型的表示和实现 算法和算法的度量
学习数据结构的主要意义和要求
意义:
数据结构和算法是计算机学科的两大支柱 数据结构是程序设计的基础 程序=算法+数据结构
存储结构分为: 顺序存储结构——借助元素在存储器中的相对位置来表示 数据元素间的逻辑关系 链式存储结构——借助指示元素存储地址的指针表示数据 元素间的逻辑关系 数据的逻辑结构与存储结构密切相关 逻辑结构
线性表
物理结构
顺序存储结构
树
图
链式存储结构
复合存储结构
h
h
元素1 1400
1345 元素2
链式存储
数据结构的形式定义为: 数据结构是一个二元组 Data_Structures = (D, S) 其中: D 是数据元素的有限集, S 是 D上关系的有限集。
数据元素的映象方法: 例用二进制位(bit)的位串表示数据元素
(321)10 = (501)8 = (101000001)2 A = (101)8 = (001000001)2
算法设计的要求
2. 可读性 算法主要是为了人的阅读与交流,其次才是为计算机执行,因此算法 应该易于人的理解;另一方面,晦涩难读的程序易于隐藏较多错误而难以 调试。 3.健壮性 当输入的数据非法时,算法应当恰当地作出反映或进行相应处理,而
1536
元素3
1346
元素4
∧
存储地址 1345 1346
存储内容 元素1 元素4
指针 1400 ∧
数据结构(C语言描述)(第2版 李学刚 参考答案 (27)[3页]
同步训练5-6 参考答案一、单项选择题1.在有向无环图G 的拓扑序列中,对图G 中任意一对顶点u 和v ,若<u,v>∈E(G),则( A )。
A .u 一定出现在v 之前B .u 一定出现在v 之后C .u 不一定出现在v 之前D .u 不一定出现在v 之后2.一个有向无环图G 的拓扑序列( D )。
A .只有一个 B .有且只有一个 C .可能有多个D .有且可能有多个3.一个有向图G 的拓扑序列( C )。
A .只有一个 B .有且只有一个 C .可能没有、可能有多个D .有且可能有多个4.如果一个有向图G 有拓扑序列,则该图一定( B )。
A .有环 B .无环 C .有唯一拓扑序列D .有多个拓扑序列5.为便于判别有向图中是否存在回路,可借助于( D )。
A .广度优先搜索算法 B .最小生成树算法 C .最短路径算法D .拓扑排序算法6.如图所示的有向无环图可以得到的不同拓扑序列的个数为( C )。
A .1B .2C .3D .47.如图所示的有向无环图可以得到的拓扑序列的个数是( C )。
A . 3B . 4C . 5D . 6EE8.如图所示有向图的一个拓扑序列是( B )。
A .EFABCDB .FCBEADC .FEABCDD .EAFCBD9.如图所示的有向图的拓扑序列是( B )。
A .cdbaeB .cadbeC .cdeabD .cabde10.对下面有向图给出了四种可能的拓扑序列,其中错误的是( C )。
A .1,5,2,6,3,4B .1,5,6,2,3,4C .5,1,6,3,4,2D .5,1,2,6,4,311.已知有向图G=(V ,E),其中V={V1,V2,V3,V4},E={<V1,V2>,<V1,V3>,<V2,V3>,<V2,V4>,<V3,V4>},图G 的拓扑序列是( A )。
数据结构(C语言版)考研复习题
数据结构(C语言版)考研复习题第1 页共19 页第一章绪论1.1 简述下列概念:数据、数据元素、数据类型、数据结构、逻辑结构、存储结构、线性结构、非线性结构。
1.2 常用的存储表示方法有哪几种?1.3 算法的时间复杂度仅与问题的规模相关吗?1.4 有时为了比较两个同数量级算法的优劣,须突出主项的常数因子,而将低次项用大"O"记号表示。
例如,设T1(n)=1.39nlgn+100n+256=1.39nlgn+O(n), T2(n)=2.0nlgn-2n=2.0lgn+O(n), 这两个式子表示,当n足够大时T1(n)优于T2(n),因为前者的常数因子小于后者。
请用此方法表示下列函数,并指出当n足够大时,哪一个较优,哪一个较劣?函数大"O"表示优劣(1) T1(n)=5n22-3n+60lgn 5n22+O(n)(2) T2(n)=3n22+1000n+3lgn 3n22+O(n)(3) T3(n)=8n22+3lgn 8n22+O(lgn)(4) T4(n)=1.5n2+6000nlgn 1.5n2+O(nlgn)第二章线性表2.1 试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。
2.2 何时选用顺序表、何时选用链表作为线性表的存储结构为宜?2.3 为什么在单循环链表中设置尾指针比设置头指针更好?2.4 下述算法的功能是什么?LinkList Demo(LinkList L){ // L 是无头结点单链表ListNode *Q,*P;if(L&&L->next){Q=L;L=L->next;P=L;while (P->next) P=P->next;P->next=Q; Q->next=NULL;}return L;}// Demo2.5设线性表的n个结点定义为(a0,a1,...a n-1),重写顺序表上实现的插入和删除算法:InsertList 和DeleteList.2.6 设顺序表L是一个递减有序表,试写一算法,将x插入其后仍保持L的有序性。
数据结构 C语言版(严蔚敏版)第7章 图
1
2
4
1
e6 2 4
2016/11/7
29
7.3 图的遍历
从已给的连通图中某一顶点出发,沿着一 些边访遍图中所有的顶点,且使每个顶点 仅被访问一次,就叫做图的遍历 ( Graph Traversal )。 图中可能存在回路,且图的任一顶点都可 能与其它顶点相通,在访问完某个顶点之 后可能会沿着某些边又回到了曾经访问过 的顶点。 为了避免重复访问,可设置一个标志顶点 是否被访问过的辅助数组 visited [ ]。
2
1 2
V2
V4
17
结论:
无向图的邻接矩阵是对称的; 有向图的邻接矩阵可能是不对称的。 在有向图中, 统计第 i 行 1 的个数可得顶点 i 的出度,统计第 j 行 1 的个数可得顶点 j 的入度。 在无向图中, 统计第 i 行 (列) 1 的个数可得 顶点i 的度。
2016/11/7
18
2
邻接表 (出度表)
adjvex nextarc
data firstarc
0 A 1 B 2 C
2016/11/7
1 0 1
逆邻接表 (入度表)
21
网络 (带权图) 的邻接表
6 9 0 2 1 C 2 8 3 D
data firstarc Adjvex info nextarc
2016/11/7
9
路径长度 非带权图的路径长度是指此路径 上边的条数。带权图的路径长度是指路径 上各边的权之和。 简单路径 若路径上各顶点 v1,v2,...,vm 均不 互相重复, 则称这样的路径为简单路径。 回路 若路径上第一个顶点 v1 与最后一个 顶点vm 重合, 则称这样的路径为回路或环。
C语言程序设计期末考试试题含答案
C语言程序设计期末考试试题含答案一、选择题(每题 2 分,共 40 分)1、以下选项中,不是 C 语言关键字的是()A intB floatC charD string答案:D解释:string 不是 C 语言的关键字,C 语言中表示字符串通常使用字符数组。
2、以下能正确表示八进制整数的是()A 0o123B 0123C 0x123D 123答案:B解释:在 C 语言中,八进制整数以数字 0 开头,所以 0123 是八进制整数。
3、以下变量定义中,合法的是()A int a=b=1;B char a='\0';C float 2a;D double a&;答案:B解释:A 选项中不能连续赋值;C 选项变量名不能以数字开头;D 选项变量名不能包含特殊字符&。
4、若有定义:int a=5, b=2; 则表达式 a/b 的值是()A 25B 2C 20D 3答案:B解释:C 语言中,两个整数相除结果为整数,舍去小数部分。
5、若有定义:int a5 ={1, 2, 3, 4, 5};则 a2的值是()A 2B 3C 4D 5答案:B解释:数组下标从 0 开始,所以 a2对应的值是 3 。
6、以下关于函数的叙述中,正确的是()A 函数可以嵌套定义B 函数可以嵌套调用C 函数可以没有返回值D 以上都不对答案:C解释:函数不能嵌套定义,但可以嵌套调用。
函数可以没有返回值,此时函数类型为 void 。
7、若有以下函数定义:```cint fun(int a, int b){return a + b;}```则调用 fun(1, 2)的返回值是()A 1B 2C 3D 4答案:C解释:函数 fun 实现了两个整数的相加,所以 fun(1, 2)的返回值是3 。
8、以下关于指针的叙述中,错误的是()A 指针可以指向变量B 指针可以指向数组C 指针可以指向函数D 指针不可以进行加减运算答案:D解释:指针可以进行加减运算,但运算的结果要根据指针所指向的数据类型来确定。
c语言数据结构面试题
c语言数据结构面试题在此篇文章中,我们将讨论一些与C语言数据结构相关的面试题。
这些问题将帮助您更好地了解C语言数据结构的概念和实践,并在面试过程中展示您的知识和技能。
问题一:什么是数据结构?答:数据结构是计算机科学中用来存储和组织数据的方式。
它涉及到数据元素之间的关系,以及对这些关系进行操作和访问的方法。
问题二:请解释以下几种常见的数据结构类型:数组、链表和栈。
答:1. 数组:数组是一种线性数据结构,用于存储固定大小的相同类型元素。
数组的元素可以通过索引进行访问,索引从0开始。
2. 链表:链表是一种动态数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的节点可以在运行时动态增加或删除。
3. 栈:栈是一种后进先出(LIFO)的数据结构。
它只允许在栈的一端进行插入和删除操作,这一端被称为栈顶。
问题三:什么是队列?请解释队列的两种常见类型:普通队列和循环队列。
答:队列是另一种常见的数据结构,它按照先进先出(FIFO)的顺序存储元素。
插入操作(入队)发生在队列的尾部,而删除操作(出队)发生在队列的头部。
普通队列是一种线性队列,它使用数组或链表来实现。
当队列满时,无法插入新的元素。
循环队列是一种巧妙地解决了普通队列满的问题的队列。
它使用循环数组实现,当队列满时,插入操作将在数组的开头继续。
问题四:请解释树的概念。
并介绍二叉树和二叉搜索树。
答:树是一种非线性数据结构,它由一组节点组成,节点之间存在层次关系。
树的顶部节点称为根节点,每个节点可以有0个或多个子节点。
二叉树是一种特殊的树,每个节点最多有两个子节点。
这两个子节点被称为左子节点和右子节点。
二叉搜索树是一种特殊的二叉树,它的左子树上的节点的值都小于根节点的值,右子树上的节点的值都大于根节点的值。
这种排列方式使得在二叉搜索树中进行搜索操作非常高效。
问题五:请解释图的概念,并介绍有向图和无向图。
答:图是一种非线性数据结构,由节点和边组成。
数据结构(c语言)试题
1、用循环链表作为存储结构的队列就就是循环队列()错误2、线性链表中各个链结点之间的地址不一定要连续。
()正确3、一个任意串就是其自身的子串()正确4、AOV网是个带权有向图()错误5、一组权值,可以唯一构造出一棵哈夫曼树。
()错误6、队列的插入操作是在队尾。
()正确7、邻接表是图的一种链式存储结构()正确8、由权值为3,6,7,2,5的叶子结点生成一棵哈夫曼树,它的带权路径长度为51()正确9、若某堆栈的输入序列为1,2.3.4,则4,3,1,2不可能就是堆栈的输出序列之一()正确10、在链队列中,即使不设置尾指针也能进行入队操作()错误11、哈夫曼树一定就是完全二叉树()错误12符号p->next出现在表达式中表示p所指的结点的内容()错误12、从源点到终点的最短路径是唯一的()错误13、队列在数据中的存储原则是后进先出()错误14、邻接表只能用于存储有向图,而邻接矩阵则可存储有向图和无向图()错误16.给定一组权值,可以唯一构造出一棵哈夫曼树()错误17、程序越短,程序运行的时间就越少()错误18、线性表的逻辑顺序与物理顺序总就是一致的()错误19、堆栈、队列与数组的逻辑结构都就是线性表结构()正确20、带头节点的单链表head为空的判定条件是head==NULL()错误1、循环队列的特点之一是不会产生()假溢出2、链栈与顺序栈相比,比较明显的优点是()不会出现上溢的情况3、若需要利用形参直接访问实参,则应把形参变量说明为()参数引用4、在一棵深度为h的具有n个元素的二叉排序树中,查找所有元素的最长查找长度为()h5、在单链表中,存储每个结点需要有两个域,一个是数据域,另一个是指针域,它指向该结点的()直接后继6、在查找过程中,若同时还要做增、删工作,这种查找则称为()动态查找7、假定一个顺序队列的队首与队尾指针分别为front与rear,存放该队列的数组长度为N,则判断队空的条件为()Front==rear8、适于对动态查找表进行高效率查找的组织结构就是()二叉排序树9.线性表是()一个有限序列,可以为空10.链表具有的特点是()可随机访问任一元素11、在一棵二叉树中,第5层上的结点数最多为()1612、静态查找表与动态查找表两者的根本差别在于()施加的操作不同13、下列陈述中正确的是()二叉树中最多只有两颗子树,并且有左右之分14、算法在发生非法操作时可以做出处理的特性称为()健壮性15、使用折半查找,线性表必须()以顺序方式存储,且元素已元素已按值排好序16、存储时,结点的地址()连续与否均可17、链表不具有的特点是()随机访问18、一个栈的入栈序列是a , b , c ,d , e,则栈的不可能的输出序列是()d,c,e,a,b19、二维数组A按行顺序存储.其中每个元素占1个存储单元。
数据结构(c语言版)课后习题答案完整版
第1章绪论5.选择题:CCBDCA6.试分析下面各程序段的时间复杂度。
(1)O(1)(2)O(m*n)(3)O(n2)(4)O(log3n)(5)因为x++共执行了n-1+n-2+……+1= n(n-1)/2,所以执行时间为O(n2)(6)O(n)第2章线性表1.选择题babadbcabdcddac2.算法设计题(6)设计一个算法,通过一趟遍历在单链表中确定值最大的结点。
ElemType Max (LinkList L ){if(L->next==NULL) return NULL;pmax=L->next; //假定第一个结点中数据具有最大值p=L->next->next;while(p != NULL ){//如果下一个结点存在if(p->data > pmax->data) pmax=p;p=p->next;}return pmax->data;(7)设计一个算法,通过遍历一趟,将链表中所有结点的链接方向逆转,仍利用原表的存储空间。
void inverse(LinkList &L) {// 逆置带头结点的单链表 Lp=L->next; L->next=NULL;while ( p) {q=p->next; // q指向*p的后继p->next=L->next;L->next=p; // *p插入在头结点之后p = q;}}(10)已知长度为n的线性表A采用顺序存储结构,请写一时间复杂度为O(n)、空间复杂度为O(1)的算法,该算法删除线性表中所有值为item的数据元素。
[题目分析] 在顺序存储的线性表上删除元素,通常要涉及到一系列元素的移动(删第i个元素,第i+1至第n个元素要依次前移)。
本题要求删除线性表中所有值为item的数据元素,并未要求元素间的相对位置不变。
因此可以考虑设头尾两个指针(i=1,j=n),从两端向中间移动,凡遇到值item的数据元素时,直接将右端元素左移至值为item的数据元素位置。
智慧树知到《算法与数据结构》章节测试答案
智慧树知到《算法与数据结构》章节测试答案绪论1、数据结构是一门研究非数值计算的程序设计问题中计算机的数据元素以及它们之间的____和运算等的学科。
A:结构B:算法C:关系D:运算正确答案:关系2、算法的描述形式包括A:自然语言B:流程图C:类程序设计语言D:N-S图正确答案:自然语言,流程图 ,类程序设计语言,N-S图3、算法的特征包括有穷性、确定性、可行性和输入输出。
A:对B:错正确答案:对4、对算法的描述包括程序形式和描述形式。
A:对B:错正确答案:对5、描述形式是算法的最终形式A:对B:错正确答案:错6、“数据结构”是介于( )、( )和( )三者之间的一门核心课程。
A:数学B:计算机硬件C:计算机软件D:语句正确答案:数学,计算机硬件,计算机软件7、著名计算机科学家沃思教授提出的公式:程序 = ( ) + ( ),也说明了数据结构的重要性。
A:算法B:语法C:数据结构D:编程环境正确答案:算法,数据结构8、描述非数值计算问题的数学模型不再是数学方程,而是数据结构( )。
A:表B:树C:图D:集合正确答案:表,树,图,集合9、数据结构是一门研究( )程序设计问题中计算机的( )以及它们之间的( )和( )等的学科。
A:非数值计算B:操作对象C:关系D:操作正确答案:非数值计算,操作对象,关系,操作10、顺序存储结构: 借助元素在存储器中的( )来表示数据元素间的逻辑关系。
A:地址B:结构C:相对位置D:数值正确答案:相对位置第一章1、()是一种最简单的线性结构。
A:图B:线性表C:树D:集合正确答案:线性表2、()线性表的数据元素可以由所描述对象的各种特征的数据项组成。
A:有序存储B:散列存储C:链式存储D:顺序存储正确答案:链式存储3、已知单向链表中指针p指向结点A,( )表示删除A的后继结点(若存在)的链操作(不考虑回收)。
A:p—>next=pB:p=p—>nextC:p=p—>next—>nextD:p—>next=p—>next—>next正确答案:p—>next=p—>next—>next4、已知last指向单向简单链表的尾结点,将s所指结点加在表尾,不正确的操作是。
DS07-图-数据结构(C语言版)(第2版)-唐国民-清华大学出版社
第七章
图
7.2
图的存储结构
图是由两部分组成,一部分是图的 顶点信息,另一部分是图顶点间的关系 信息(边)。所以要想将图的全部信息存 储到计算机中,也必须将顶点的信息和 顶点间的关系信息都存储。
第七章
图
一、图的邻接矩阵存储
设图 G = (V, E)是一个有 n 个顶点的图, 有一个记录各个顶点信息v0 ,v1, v2, …, vn-1 的顶点表,可以用顺序方式或链式方式来存储 顶点表;而图的边用一个二维数组表示,它是 一个n×n的矩阵(邻接矩阵),用于表示顶点 之间的邻接关系。定义为:
W (i , j ), A.Edge [i ][ j ] = , aij 0,
A
第七章
图
邻接矩阵表示法中图的类型定义:
#define MAXSIZE 100 /*图的顶点个数*/ typedef int datatype; typedef struct { datatype vexs[MAXSIZE]; /*顶点信息表*/ int edges[MAXSIZE][ MAXSIZE];/*邻接矩阵*/ int n,e ; /*顶点数和边数*/ }graph;
B A C E D
A B vexs C D E
有向图
0 0 edges 0 0 0
1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0
第七章
图
2
20
40
5
子图:设有两个图 G=(V, E) 和 G’=(V’, E’)。 若V’ V 且 E’E, 则称图G’是图G的子图。
第七章
图
路径:在图 G=(V, E) 中, 若存在一个顶点序列vp1, vp2,
数据结构考试题库及答案
数据结构考试题库及答案一、选择题1. 下列哪个不是线性结构?A. 栈B. 队列C. 双向链表D. 树答案:D2. 在顺序存储结构中,数据元素的物理位置与逻辑位置相同的是哪种结构?A. 栈B. 队列C. 线性表D. 树答案:C3. 下列哪种排序算法的时间复杂度是O(nlogn)?A. 冒泡排序B. 选择排序C. 快速排序D. 插入排序答案:C4. 在二叉树中,度为0的节点称为()。
A. 根节点B. 内节点C. 叶子节点D. 父节点答案:C5. 下列哪种图的邻接矩阵是对称的?A. 有向图B. 无向图C. 有向连通图D. 无向连通图答案:B二、填空题6. 在链表中的每个节点至少包含两个部分:一个是存储数据元素的数据域,另一个是存储下一个节点地址的指针域。
7. 在顺序表中,元素之间的逻辑关系是由它们的相对位置来体现的。
8. 快速排序的基本思想是:在待排序序列中选取一个基准元素,将序列中所有小于基准元素的元素放在基准元素前面,所有大于基准元素的元素放在基准元素后面。
9. 图中的每个节点称为顶点,顶点之间的连线称为边。
10. 在哈希表中,哈希函数的目的是将关键字映射到散列地址。
三、判断题11. 在顺序表中插入一个元素的时间复杂度为O(1)。
()答案:错误。
插入一个元素的时间复杂度为O(n),因为可能需要移动其他元素。
12. 在链表中删除一个元素的时间复杂度为O(n)。
()答案:错误。
删除一个元素的时间复杂度为O(1),只要找到该元素的前一个节点即可。
13. 二分查找只适用于有序的顺序表。
()答案:正确。
14. 在二叉树中,任意节点的度数不会超过2。
()答案:正确。
15. 图的邻接表表示法比邻接矩阵表示法更加节省空间。
()答案:正确。
四、应用题16. 请用C语言实现一个顺序栈的数据结构,并给出入栈、出栈和判断栈空的操作。
答案:```c#define MAXSIZE 100typedef struct {int data[MAXSIZE];int top;} SeqStack;// 初始化栈void InitStack(SeqStack s) {s->top = -1;}// 判断栈是否为空int StackEmpty(SeqStack s) {return s->top == -1;}// 入栈int Push(SeqStack s, int x) {if (s->top == MAXSIZE - 1) {return 0; // 栈满}s->data[++s->top] = x;return 1;}// 出栈int Pop(SeqStack s, int x) {if (s->top == -1) {return 0; // 栈空}x = s->data[s->top--];return 1;}```17. 请简述二分查找的基本思想。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//对尚未被访问的邻接点递归调用 DFS 算法进行深度优先遍历 p=p->link;//查找下一个邻接点 } }/*DFS*/ void blt(vexnode ag[],int n)//对图按深度优先遍历搜索 { int i; int flag[M]; for(i=1;i<=n;i++) flag[i]=0;//初始化标志组 flag for(i=1;i<=n;i++) if(flag[i]==0)
return; } cout<<endl; cout<<"是否继续?(输入 n 结束,输入 y 有效!)"<<endl; cin>>flag; } cout<<"程序结束,再见!"<<endl; }
#include<stdio.h> #include<iostream.h> #include<malloc.h> #define M 50 typedef char vextype;//顶点数据类型 char typedef struct node //定义表结点类型 {
int adjvex;//邻接点域 struct node *link;//指针域 }edgenode,*Edgenode; typedef struct headnode//定义表头结点类型 { vextype vexdata;//顶点数据域 struct node *firstarc;//指针域指向链表中的第一个结点 }vexnode,*Vexnode; typedef vexnode adjlist[M];//adjlist 为邻接表类型 //无向图的邻接表生成算法 void creatlist1(vexnode ag[],int n) { edgenode *p; int i,j; char ch; cout<<"请输入顶点个数:"; cin>>n; for(i=1;i<=n;i++) {
while(flag=='y') {
cout<<"请选择图的种类(1 代表有向图,2 代表无向图)"ห้องสมุดไป่ตู้<endl; cin>>kind;//输入图的种类 switch(kind) { case 1:cout<<"---------------创建有向图---------------"<<endl;
cout<<"输入下一条边的两个顶点序号:"; cin>>i>>j;//再次输入下一条边的两个顶点序号 } }/*creatlist1*/ //有向图邻接表生成算法 void creatlist2(vexnode ag[],int n) { edgenode *p; int i,j; char ch; cout<<"请输入顶点个数:"; cin>>n; for(i=1;i<=n;i++) { cout<<"第"<<i<<"个顶点为:"; cin>>ch;//读入顶点信息 ag[i].vexdata=ch;//设顶点为字符型 ag[i].firstarc=NULL;//将每个链表初始化为空 } cout<<"以(0,0)为输入结束符"<<endl; cout<<"输入一条边依附的两个顶点序号:"; cin>>i>>j; while((i>0)&&(j>0))//输入的(i,j)为(0,0)作为结束符号 { p=(edgenode*)malloc(sizeof(edgenode));//生成邻接序号为 j 的表结点 p->adjvex=j; p->link=ag[i].firstarc; ag[i].firstarc=p;//结点 j 插入到第 i 个链表 cout<<"输入下一条边的两个顶点序号:"; cin>>i>>j;//再次输入下一条边的两个顶点序号 } }/*creatlist2*/ void DFS(vexnode ag[],int v,int flag[])//从序号为 v 的顶点对图进行深度优先遍历 { edgenode *p; int i; flag[v]=1; cout<<ag[v].vexdata<<" "; p=ag[v].firstarc;//p 最初指向 v 的第一个邻接点 while(p!=NULL) { i=p->adjvex;//取出 p 指针所指向的邻接点的序号 if(flag[i]==0)
DFS(ag,i,flag);//调用深度优先算法 DFS } void BFS(Vexnode g,int v,int c[])//对图进行广度遍历 {
int q[M],r=0,f=0; Edgenode p; c[v]=1; cout<<g[v].vexdata<<" "; q[0]=v; while(f<=r) {
v=q[f++]; p=g[v].firstarc; while(p!=NULL) {
v=p->adjvex; if(c[v]==0) {
c[v]=1; cout<<g[v].vexdata<<" "; q[++r]=v; } p=p->link; } } }/*BFS*/ void main() { int n=0,j,k,kind,i; char flag='y'; int f[M]; vexnode v1[M],v2[M];
f[i]=0; cout<<"深度遍历为:"; DFS(v2,k,f);//深度遍历 cout<<endl; for(i=0;i<M;i++)
f[i]=0; cout<<"广度遍历为:"; BFS(v2,k,f);//广度遍历 break; default:cout<<"输入错误,程序结束!"<<endl;
cout<<"第"<<i<<"个顶点为:"; cin>>ch;//读入顶点信息 ag[i].vexdata=ch;//设顶点为字符型 ag[i].firstarc=NULL;//将每个链表初始化为空 } cout<<"以(0,0)为输入结束符"<<endl; cout<<"输入一条边依附的两个顶点序号:"; cin>>i>>j; while((i>0)&&(j>0))//输入的(i,j)为(0,0)作为结束符号 { p=(edgenode*)malloc(sizeof(edgenode));//生成邻接序号为 j 的表结点 p->adjvex=j; p->link=ag[i].firstarc; ag[i].firstarc=p;//结点 j 插入到第 i 个链表 p=(edgenode*)malloc(sizeof(edgenode));//生成临界点序号为 i 的表结点 p->adjvex=i; p->link=ag[j].firstarc; ag[j].firstarc=p;//结点 i 插入到第 j 个链表的头部
creatlist1(v1,n);//创建有向图 cout<<"开始遍历的结点序号为:"; cin>>j; for(i=0;i<M;i++)
f[i]=0; cout<<"深度遍历为:"; DFS(v1,j,f);//深度遍历 cout<<endl; for(i=0;i<M;i++)
f[i]=0; cout<<"广度遍历为:"; BFS(v1,j,f);//广度遍历 break; case 2:cout<<"---------------创建无向图----------------"<<endl; creatlist2(v2,n);//创建无向图 cout<<"开始遍历的结点序号为:"; cin>>k; for(i=0;i<M;i++)