无向图的存储及深度和广度优先遍历
计算机专业基础综合数据结构图历年真题试卷汇编4_真题无答案
计算机专业基础综合数据结构（图）历年真题试卷汇编4(总分58, 做题时间90分钟)6. 综合题1.已知一图如下图所示：(1)写出全部拓扑排序；(2)以V1为源点，以V8为终点，给出所有事件允许发生的最早时间和最晚时间，并给出关键路径；(3)求V1结点到各点的最短距离。
【北京邮电大学2000五(15分)】SSS_TEXT_QUSTI2.(1)对于有向无环图，叙述求拓扑有序序列的步骤；(2)对于以下的图，写出它的四个不同的拓扑有序序列。
【南开大学1998二(12分)】SSS_TEXT_QUSTI3.有向图的拓扑排序能否用图的深度搜索模式来查找?若能，请简述方法；若不能，请简述原因。
【西北大学2000二、8(5分)】SSS_TEXT_QUSTI4.下图是带权的有向图G的邻接表表示法，求：(1)以结点V1出发深度遍历图G 所得的结点序列；(2)以结点V1出发广度遍历图G所得的结点序列；(3)从结点V1到结点V8的最短路径；(4)从结点V1到结点V8的关键路径。
【中国海洋大学1999四(10分)】SSS_TEXT_QUSTI5.下表给出了某工程各工序之间的优先关系和各工序所需时间。
(1)画出相应的AOE网； (2)列出各事件的最早发生时间，最迟发生时间；(3)找出关键路径并指明完成该工程所需最短时间。
【山东大学2002七(15分)】【北京交通大学1995六(15分)】SSS_TEXT_QUSTI6.请写出应填入下列叙述中( )内的正确答案。
某一工程作业的网络图如图所示，其中箭头表示作业，箭头边的数字表示完成作业所需的天数。
箭头前后的圆圈表示事件，圆圈中的数字表示事件的编号。
用事件编号的序列(例如0一2—7—9一11)表示进行作业的路径。
完成此工程的关键路径是(A)，完成此工程所需的最少天数为(B)天，此工程中具有最大充裕天数的事件是(C)，充裕天数是(D)。
关键路径上的事件的充裕天数是(E)。
【上海大学2002三(10分)】SSS_TEXT_QUSTI7.求出下面AOE网中的关键路径(要求给出各个顶点的最早发生时间和最迟发生时间，并画出关键路径)。
第7章图的深度和广度优先搜索遍历算法
和树的遍历类似，我们希望从图中某顶点出发对图中每个顶点访问一次，而且只访问 一次，这一过程称为图的遍历(traversing graph)。 本节介绍两种遍历图的规则：深度优先搜索和广度优先搜索。 这两种方法既适用于无向图，也适用于有向图。
7.3.1 深度优先搜索遍历 一．思路： 从图中某一点（如A）开始，先访问这一点，然后任选它的一个邻点（如V0） 访问，访问完该点后，再任选这个点V0的一个邻点 （ 如 W ）访问，如此向 纵深方向访问。直到某个点没有其他未访问的邻点为止，则返回到前一个点。 再任选它的另一个未访问过的邻点 （ 如X ）继续重复上述过程的访问，直到全 部点访问完为止。 图(a)的遍历的结果:V1V2V4V8V5V3V6V7 或V1V3V7V6V2V5V8V4
p
v0 w x v 1
V
0
v 2
V
0
typedef struct {VEXNODE adjlist［MAXLEN］; // 邻接链表表头向量 int vexnum, arcnum; // 顶点数和边数 int kind; // 图的类型 }ADJGRAPH;
W W
X
X
7.3.2 广度优先搜索遍历 一.思路：
V
0
A V
0
W W
XXΒιβλιοθήκη 二．深度优先搜索算法的文字描述： 算法中设一数组visited，表示顶点是否访问过的标志。数组长度为 图的顶点数，初值均置为0，表示顶点均未被访问，当Vi被访问过，即 将visitsd对应分量置为1。将该数组设为全局变量。 { 确定从G中某一顶点V0出发，访问V0； visited［V0］ = 1； 找出G中V0的第一个邻接顶点->w； while (w存在) do { if visited［w］ == 0 继续进行深度优先搜索； 找出G中V0的下一个邻接顶点->w；} }
数据结构试题及答案()
1. 1.数据结构是指数据及其相互之间的______________。
当结点之间存在M对N（M：N）的联系时，称这种结构为_____________________。
2. 2.队列的插入操作是在队列的___尾______进行，删除操作是在队列的____首______进行。
3. 3.当用长度为N的数组顺序存储一个栈时，假定用top==N表示栈空，则表示栈满的条件是___top==0___(要超出才为满)_______________。
4. 4.对于一个长度为n的单链存储的线性表，在表头插入元素的时间复杂度为_________，在表尾插入元素的时间复杂度为____________。
5. 5.设W为一个二维数组，其每个数据元素占用4个字节，行下标i从0到7 ，列下标j从0到3 ，则二维数组W的数据元素共占用＿_____＿个字节。
W中第6 行的元素和第4 列的元素共占用＿_______＿个字节。
若按行顺序存放二维数组W，其起始地址为100，则二维数组元素W[6，3]的起始地址为＿________＿。
6. 6.广义表A= (a,(a,b),((a,b),c)),则它的深度为____________，它的长度为____________。
7.7.二叉树是指度为2的____________________树。
一棵结点数为N的二叉树，其所有结点的度的总和是_____________。
8.8.对一棵二叉搜索树进行中序遍历时，得到的结点序列是一个______________。
对一棵由算术表达式组成的二叉语法树进行后序遍历得到的结点序列是该算术表达式的__________________。
9.9.对于一棵具有n个结点的二叉树，用二叉链表存储时，其指针总数为_____________个，其中_______________个用于指向孩子，_________________个指针是空闲的。
10.10.若对一棵完全二叉树从0开始进行结点的编号，并按此编号把它顺序存储到一维数组A中，即编号为0的结点存储到A[0]中。
dfs和bfs算法
dfs和bfs算法深度优先搜索（DFS）和广度优先搜索（BFS）是图论中常用的两种搜索算法，也是许多算法题中的基础算法。
本文将从什么是图、什么是搜索算法开始介绍DFS、BFS的基本原理以及应用场景。
一、图的概念图是由节点集合以及它们之间连线所组成的数据结构。
图分为有向图和无向图两种，有向图中的边具有一定的方向性，而无向图中的边是没有方向的。
二、DFS（深度优先搜索）深度优先搜索从一个点开始，根据规定的遍历方式始终向着深度方向搜索下去，直到到达目标节点或者无法继续搜索为止。
具体实现可以用递归或者非递归的方式进行。
1、深度优先搜索的框架def dfs(v,visited,graph):visited[v] = True #将节点v标记为已经被访问#遍历v的所有连接节点for w in graph[v]:if not visited[w]:dfs(w,visited,graph)2、深度优先搜索的应用DFS常用来解决最长路径问题、拓扑排序问题以及判断图是否存在环。
三、BFS（广度优先搜索）广度优先搜索是从一个点开始，逐层扩散的搜索方式。
具体实现可以用队列实现。
1、广度优先搜索的框架def bfs(start,graph):visited = [False] * len(graph) #标记所有节点为未访问queue = [start] #队列存储已经访问过的节点visited[start] = True #起始点被标记为已经访问过while queue:v = queue.pop(0) #弹出队列首节点#遍历该节点的所有连接节点for w in graph[v]:if not visited[w]:visited[w] = True #标记该节点已经被访问queue.append(w) #加入队列2、广度优先搜索的应用BFS常用来解决最短路径问题，如迷宫问题、网络路由问题等。
四、DFS和BFS的区别DFS从一个节点开始，向下深度优先搜索，不断往下搜索直到无路可走才返回，因此将搜索过的节点用栈来存储。
如果从无向图的任一顶点出发进行一次深度优先遍历
如果从无向图的任一顶点出发进行一次深度优先遍历无向图的深度优先遍历是图论中的一种重要算法，它沿着图的深度方向遍历图，搜索所有可以到达的顶点和边。
它实际上是一种递归地搜索算法，在搜索过程中，将当前顶点作为出发点，继续穿透搜索其邻居顶点，每次只能穿过一条边，直至所有的顶点都被搜索到。
无向图的深度优先遍历可以使用递归或迭代方式实现。
以递归方式实现为例，首先定义一个递归函数dfs(V,E)，它将由两个参数V、E指定：其中V是当前顶点，而E是图中边的矩阵表示。
从V出发，搜索以V为顶点的所有边，标记V已访问，然后搜索其邻居顶点：对每个邻居顶点Vi，如果Vi未被访问，则调用dfs(Vi,E)，递归搜索；否则，跳过Vi，继续搜索下一个邻居顶点，直至搜索完该层V的所有邻居节点，最后结束dfs函数，而无向图的深度优先遍历即完成，实际开发中，对每个访问到的顶点，都会进行处理，以完成实际任务。
无向图的深度优先遍历有多种应用，比如搜索最短路径、广度优先遍历、最小生成树、连通子图的检测等。
比如在搜索问题上，深度优先搜索算法是一种在未知环境中找到一条从初始状态到目标状态的最优路径的有效算法。
在社交网络中，深度优先搜索算法可用于搜索可能活跃的小组和社交群体。
在信号处理等其它很多领域也有应用，比如信号传播模型、搜索最近噪声或者搜索最小邻近环路等。
而在机器学习领域中，深度优先搜索算法也可用于有监督学习中的决策树算法或者无监督学习中的聚类算法，比如基于聚类算法的机器学习系统可以实现自动把文档或者图像数据分类存储，从而减少人为的繁琐搜索工作，提高工作效率。
总之，无向图的深度优先遍历是一种非常重要的算法，它有着多种应用，可以有效地帮助完成许多任务，从而大大提高工作效率。
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。
功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。
按照惯例，先上代码，注释超详细：#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 。
图练习与答案
一、应用题1．首先将如下图所示的无向图给出其存储结构的邻接链表表示，然后写出对其分别进行深度，广度优先遍历的结果。
1题图答．深度优先遍历序列：125967384宽度优先遍历序列：123456789注：（1）邻接表不唯一，这里顶点的邻接点按升序排列（2）在邻接表确定后，深度优先和宽度优先遍历序列唯一（3）这里的遍历，均从顶点1开始2．给出图G：（1）．画出G的邻接表表示图；（2）．根据你画出的邻接表，以顶点①为根，画出G的深度优先生成树和广度优先生成树。
（3）宽度优先生成树3.在什么情况下，Prim算法与Kruskual算法生成不同的MST？答．在有相同权值边时生成不同的MST，在这种情况下，用Prim或Kruskal也会生成不同的MST4．已知一个无向图如下图所示，要求分别用Prim 和Kruskal 算法生成最小树（假设以①为起点，试画出构造过程）。
答．Prim 算法构造最小生成树的步骤如24题所示，为节省篇幅，这里仅用Kruskal 算法，构造最小生成树过程如下：（下图也可选(2,4)代替(3,4),(5,6)代替(1,5)）5．G=(V,E)是一个带有权的连通图,则：（1）．请回答什么是G 的最小生成树； （2）．G 为下图所示,请找出G 的所有最小生成树。
28题图答．（1）最小生成树的定义见上面26题 （2）最小生成树有两棵。
（限于篇幅，下面的生成树只给出顶点集合和边集合，边以三元组（Vi,Vj,W ）形式），其中W 代表权值。
V （G ）={1，2，3，4，5} E1(G)={(4，5，2)，（2，5，4），（2，3，5），（1，2，7）}；E2(G)={(4，5，2），（2，4，4），（2，3，5），（1，2，7）}6．请看下边的无向加权图。
（1）．写出它的邻接矩阵。
（2）．按Prim 算法求其最小生成树，并给出构造最小生成树过程中辅助数组的各分量值。
辅助数组各分量值：7．已知世界六大城市为:(Pe)、纽约(N)、巴黎(Pa)、伦敦(L) 、东京(T) 、墨西哥(M),下表给定了这六大城市之间的交通里程:世界六大城市交通里程表(单位:百公里)（1）．画出这六大城市的交通网络图;（2）．画出该图的邻接表表示法;（3）．画出该图按权值递增的顺序来构造的最小(代价)生成树.8．已知顶点1-6和输入边与权值的序列（如右图所示）：每行三个数表示一条边的两个端点和其权值，共11行。
算法设计：深度优先遍历和广度优先遍历
算法设计：深度优先遍历和广度优先遍历实现深度优先遍历过程1、图的遍历和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。
它是许多图的算法的基础。
深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。
它们对无向图和有向图均适用。
注意：以下假定遍历过程中访问顶点的操作是简单地输出顶点。
2、布尔向量visited[0．．n-1]的设置图中任一顶点都可能和其它顶点相邻接。
在访问了某顶点之后，又可能顺着某条回路又回到了该顶点。
为了避免重复访问同一个顶点，必须记住每个已访问的顶点。
为此，可设一布尔向量visited[0．．n-1]，其初值为假，一旦访问了顶点Vi之后，便将visited[i]置为真。
--------------------------深度优先遍历(Depth-First Traversal)1．图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。
在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。
若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。
若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。
图的深度优先遍历类似于树的前序遍历。
采用的搜索方法的特点是尽可能先对纵深方向进行搜索。
这种搜索方法称为深度优先搜索(Depth-First Search)。
相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。
2、深度优先搜索的过程设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。
若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。
浅析深度优先和广度优先遍历实现过程、区别及使用场景
浅析深度优先和⼴度优先遍历实现过程、区别及使⽤场景⼀、什么是深度/⼴度优先遍历？ 深度优先遍历简称DFS（Depth First Search），⼴度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种⽅式。
这两种遍历⽅式有什么不同呢？我们来举个栗⼦： 我们来到⼀个游乐场，游乐场⾥有11个景点。
我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？1、深度优先遍历 第⼀种是⼀头扎到底的玩法。
我们选择⼀条⽀路，尽可能不断地深⼊，如果遇到死路就往回退，回退过程中如果遇到没探索过的⽀路，就进⼊该⽀路继续深⼊。
在图中，我们⾸先选择景点1的这条路，继续深⼊到景点7、景点8，终于发现⾛不动了： 于是，我们退回到景点7，然后探索景点10，⼜⾛到了死胡同。
于是，退回到景点1，探索景点9： 按照这个思路，我们再退回到景点0，后续依次探索景点2、3、5、4、发现相邻的都玩过了，再回退到3，再接着玩6，终于玩遍了整个游乐场： 具体次序如下图，景点旁边的数字代表探索次序。
当然还可以有别的排法。
像这样先深⼊探索，⾛到头再回退寻找其他出路的遍历⽅式，就叫做深度优先遍历（DFS）。
这⽅式看起来很像⼆叉树的前序遍历。
没错，其实⼆叉树的前序、中序、后序遍历，本质上也可以认为是深度优先遍历。
2、⼴度优先遍历 除了像深度优先遍历这样⼀头扎到底的玩法以外，我们还有另⼀种玩法：⾸先把起点相邻的⼏个景点玩遍，然后去玩距离起点稍远⼀些（隔⼀层）的景点，然后再去玩距离起点更远⼀些（隔两层）的景点… 在图中，我们⾸先探索景点0的相邻景点1、2、3、4： 接着，我们探索与景点0相隔⼀层的景点7、9、5、6： 最后，我们探索与景点0相隔两层的景点8、10： 像这样⼀层⼀层由内⽽外的遍历⽅式，就叫做⼴度优先遍历（BFS）。
这⽅式看起来很像⼆叉树的层序遍历。
没错，其实⼆叉树的层序遍历，本质上也可以认为是⼴度优先遍历。
图练习与答案
一、应用题1． 首先将如下图所示的无向图给出其存储结构的邻接链表表示，然后写出对其分别进行深度，广度优先遍历的结果。
1题图答．深度优先遍历序列：4宽度优先遍历序列：9 & 注：（1）邻接表不唯一，这里顶点的邻接点按升序排列（2）在邻接表确定后，深度优先和宽度优先遍历序列唯一 （3）这里的遍历，均从顶点1开始 2．给出图G ：（1）．画出G 的邻接表表示图； （2）．根据你画出的邻接表，以顶点①为根，画出G 的深度优先生成树和广度优先生成树。
~（3）宽度优先生成树~3.在什么情况下，Prim 算法与Kruskual 算法生成不同的MST答．在有相同权值边时生成不同的MST ，在这种情况下，用Prim 或Kruskal 也会生成不（同的MST4．已知一个无向图如下图所示，要求分别用Prim 和Kruskal 算法生成最小树（假设以①为起点，试画出构造过程）。
》答．Prim 算法构造最小生成树的步骤如24题所示，为节省篇幅，这里仅用Kruskal 算法，构造最小生成树过程如下：（下图也可选(2,4)代替(3,4),(5,6)代替(1,5)） !5．G=(V,E)是一个带有权的连通图,则：（1）．请回答什么是G 的最小生成树； （2）．G 为下图所示,请找出G 的所有最小生成树。
28题图：答．（1）最小生成树的定义见上面26题（2）最小生成树有两棵。
（限于篇幅，下面的生成树只给出顶点集合和边集合，边以三元组（Vi,Vj,W ）形式），其中W 代表权值。
V （G ）={1，2，3，4，5} E1(G)={(4，5，2)，（2，5，4），（2，3，5），（1，2，7）}；E2(G)={(4，5，2），（2，4，4），（2，3，5），（1，2，7）}6．请看下边的无向加权图。
（1）．写出它的邻接矩阵。
（2）．按Prim 算法求其最小生成树，并给出构造最小生成树过程中辅助数组的各分量值。
辅助数组内各分量值：/)7．已知世界六大城市为:北京(Pe)、纽约(N)、巴黎(Pa)、伦敦(L) 、东京(T) 、墨西哥(M),下表给定了这六大城市之间的交通里程:世界六大城市交通里程表(单位:百公里)]（1）．画出这六大城市的交通网络图;（2）．画出该图的邻接表表示法;（3）．画出该图按权值递增的顺序来构造的最小(代价)生成树.8．已知顶点1-6和输入边与权值的序列（如右图所示）：每行三个数表示一条边的两个端点和其权值，共11行。
图的定义和基本术语图的存储结构图的遍历生成树最短路径
DeleteVex(&G, v) //删除顶点 初始条件: 图G存在， v和G中顶点有相同特性 。 操作结果:删除G中顶点v及其相关的弧。
InsertArc(&G, v, w) //插入弧 初始条件:图G存在，v 和w是G中两个顶点。 操作结果:在G中增添弧<v,w>，若G是无向的， 则还增添对称弧<w,v>。
DestroyGraph (&G ) // 销毁 初始条件:图G存在。 操作结果:销毁图G 。
LocateVex(G, u) // 定位 初始条件:图G存在，u 和G中顶点有相同特性 。 操作结果: 若G中存在顶点u ，则返回该顶点在 图中位置 ；否则返回其它信息。
GetVex(G, v)// 求值 初始条件:图G存在，v 是G中某个顶点。 操作结果:返回v的值。
//{有向图，有向网，无向图，无向网}
typedef struct ArcCell {// 弧的定义 VRType adj;//VRType是顶点关系类型。对无权图，
//用1或0表示相邻否；对带权图，则为权值类型。 InfoType *info; // 该弧相关信息的指针 } ArcCell ,
AdjMatrix[MAX_VERTEX_NUM] [MAX_VERTEX_NUM];
V2
V3
0110 0000 0001 10 0 0
//－ －图的数组(邻接矩阵)存储表示－－
#define INFINITY INT_MAX //最大值∞ #define MAX_VERTEX_NUM 20//最大顶点个数 typedef enum{DG,DN,UDG, UDN }graphkind；
表示，称为无向边；
图的遍历(深度优先遍历和广度优先遍历)
遍历规则 从图中某结点v0出发，深度优先遍历（DFS: Depth First Search）图的规则为： 访问v0； 对v0的各个出点v01，v02，…，v0m，每次从它们中按一定方式（也可任选）选取一个未被访问过的结点，从该结点出发按深度优先遍历方式遍历。 然，因为我们没有规定对出点的遍历次序，所以，图的深度优先遍历结果一般不唯一。
20.2 深度优先遍历
例如，对图 20‑1给出的有向图与无向图，一些遍历结果（结点访问次序）为： 左图：从1出发：1，2，4，5；或1，5，2，4 从2出发：2，1，5，4；或2，4，1，5 右图：从a出发：a，b，c，d；或a，b，d，c; … …
A 如果不想让visited或top做为函数参数，也可以在函数中将其定义为static型量。但是，这样的程序是不可再入的，即函数再次被调用时，static型的量也不重新初始化，造成错误！
上面函数中的参数visited和top实质上是中间变量，只是为了避免在递归调用时重新初始化而放在参数表中，造成使用的不方便，为此，做个包装程序： long DFS1(int g[][CNST_NumNodes], long n, long v0, long *resu ) { char *visited; long top=0; visited = new char[n]; for (long i=0; i<n; i++) visited[i]=0; long num=DFS1( g, n, v0, visited, resu, top ); delete visited; return num; }
深度优先遍历非递归算法的一般性描述。
long DFS_NR(图g，结点v0)
单击此处可添加副标题
1102编号数据结构试卷带答案
数据结构试卷（一）一、选择题（20分）1．组成数据的基本单位是（ 1.C）。
(A) 数据项(B) 数据类型(C) 数据元素(D) 数据变量2．设数据结构A=(D，R)，其中D={1，2，3，4}，R={r}，r={<1，2>，<2，3>，<3，4>，<4，1>}，则数据结构A是（C）。
(A) 线性结构(B) 树型结构(C) 图型结构(D) 集合3．数组的逻辑结构不同于下列（D）的逻辑结构。
(A) 线性表(B) 栈(C) 队列(D) 树4．二叉树中第i(i≥1)层上的结点数最多有（C）个。
(A) 2i(B) 2i(C) 2i-1(D) 2i-15．设指针变量p指向单链表结点A，则删除结点A的后继结点B需要的操作为（.A ）。
(A) p->next=p->next->next(B) p=p->next(C) p=p->next->next(D) p->next=p6．设栈S和队列Q的初始状态为空，元素E1、E2、E3、E4、E5和E6依次通过栈S，一个元素出栈后即进入队列Q，若6个元素出列的顺序为E2、E4、E3、E6、E5和E1，则栈S的容量至少应该是（.C ）。
(A) 6(B) 4(C) 3(D) 27．将10阶对称矩阵压缩存储到一维数组A中，则数组A的长度最少为（C ）。
(A) 100(B) 40(C) 55(D) 808．设结点A有3个兄弟结点且结点B为结点A的双亲结点，则结点B的度数数为（8.B(A) 3(B) 4(C) 5(D) 19．根据二叉树的定义可知二叉树共有（ B）种不同的形态。
(A) 4(B) 5(C) 6(D) 710.设有以下四种排序方法，则（ B ）的空间复杂度最大。
(A) 冒泡排序(B) 快速排序(C) 堆排序(D) 希尔排序二、填空题(30分)1.设顺序循环队列Q[0：m-1]的队头指针和队尾指针分别为F和R，其中队头指针F指向当前队头元素的前一个位置，队尾指针R指向当前队尾元素所在的位置，则出队列的语句为F =____________;。
Java实现无向图的建立与遍历
Java实现⽆向图的建⽴与遍历⼀、基于邻接矩阵表⽰法的⽆向图 邻接矩阵是⼀种利⽤⼀维数组记录点集信息、⼆维数组记录边集信息来表⽰图的表⽰法，因此我们可以将图抽象成⼀个类，点集信息和边集信息抽象成类的属性，就可以在Java中描述出来，代码如下：1class AMGraph{23private String[] vexs = null; //点集信息45private int[][] arcs = null; //边集信息67 } 每⼀个具体的图，就是该类的⼀个实例化对象，因此我们可以在构造函数中实现图的创建，代码如下：1public AMGraph(int vexNum,int arcNum) { //输⼊点的个数和边的个数23this.vexs = new String[vexNum];4this.arcs = new int[vexNum][vexNum];56 System.out.print("请依次输⼊顶点值，以空格隔开：");7 Scanner sc = new Scanner(System.in);8for(int i = 0; i < vexNum; i++) { //根据输⼊建⽴点集9this.vexs[i] = sc.next();10 }1112for(int i = 0; i < vexNum; i++) { //初始化边集13for(int j = 0; j < vexNum; j++) {14this.arcs[i][j] = 0; //0表⽰该位置所对应的两顶点之间没有边15 }16 }1718 start:for(int i = 0; i < arcNum; i++) { //开始建⽴边集1920 sc = new Scanner(System.in);21int vex1Site = 0;22int vex2Site = 0;23 String vex1 = null;24 String vex2 = null;2526 System.out.print("请输⼊第" + (i+1) + "条边所依附的两个顶点，以空格隔开：");27 vex1 = sc.next();28 vex2 = sc.next();29for(int j = 0; j < this.vexs.length; j++) { //查找输⼊的第⼀个顶点的位置30if (this.vexs[j].equals(vex1)) {31 vex1Site = j;32break;33 }34if (j == this.vexs.length - 1) {35 System.out.println("未找到第⼀个顶点，请重新输⼊！");36 i--;37continue start;38 }39 }40for (int j = 0; j < this.vexs.length; j++) { //查找输⼊的第⼆个顶点的位置41if(this.vexs[j].equals(vex2)) {42 vex2Site = j;43break;44 }45if (j == this.vexs.length - 1) {46 System.out.println("未找到第⼆个顶点，请重新输⼊！");47 i--;48continue start;49 }50 }51if(this.arcs[vex1Site][vex2Site] != 0) { //检测该边是否已经输⼊52 System.out.println("该边已存在！");53 i--;54continue start;55 }else {56this.arcs[vex1Site][vex2Site] = 1; //1表⽰该位置所对应的两顶点之间有边57this.arcs[vex2Site][vex1Site] = 1; //对称边也置158 }59 }60 System.out.println("基于邻接矩阵的⽆向图创建成功！");61 sc.close();62 } 创建好图后，我们还要实现图的遍历。
图的遍历实验报告
实验四：图的遍历题目：图及其应用——图的遍历班级：姓名：学号：完成日期：一.需求分析1.问题描述：很多涉及图上操作的算法都是以图的遍历操作为基础的。
试写一个程序，演示在连通的无向图上访问全部结点的操作。
2.基本要求：以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。
3.测试数据：教科书图7.33。
暂时忽略里程，起点为北京。
4.实现提示：设图的结点不超过30个，每个结点用一个编号表示（如果一个图有n个结点，则它们的编号分别为1,2,…,n）。
通过输入图的全部边输入一个图，每个边为一个数对，可以对边的输入顺序作出某种限制，注意，生成树的边是有向边，端点顺序不能颠倒。
5.选作内容：（1）.借助于栈类型（自己定义和实现），用非递归算法实现深度优先遍历。
（2）.以邻接表为存储结构，建立深度优先生成树和广度优先生成树，再按凹入表或树形打印生成树。
二.概要设计1.为实现上述功能，需要有一个图的抽象数据类型。
该抽象数据类型的定义为：ADT Graph{数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。
数据关系R：R={VR}VR={<v，w> | v，w v且P(v，w)，<v，w>表示从v到w得弧，谓词P(v，w)定义了弧<v，w>的意义或信息}} ADT Graph2.此抽象数据类型中的一些常量如下：#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};3.树的结构体类型如下所示：typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。
图结构习题
第6章 图【例6-3】已知一个无向图的邻接表如图6—5所示,要求:（1)画出该无向图;(2)根据邻接表,分别写出用DFS (深度优先搜索)和BFS (广度优先搜索）算法从顶点V0开始遍历该图后所得到的遍历序列.解：（1）该无向图如图6-6所示。
(2）根据该无向图的邻接表表示，从顶点V0开始的深度优先遍历序列为：V0、V2、V3、V1、V4、V6、V5.广度优先遍历序列为V0、V2、V5、V6、V1、V3、V4。
从图的逻辑结构上来讲，从图中某个顶点开始的深度(或广度)优先遍历序列不一定是唯一的。
这是因为在逻辑结构中，并没有对每个顶点的所有邻接点规定它们之间的先后顺序，这样在搜索算法中选取第—个邻接点和下一个邻接点时可能会有不同的结果.但是在存储结构中，明确地给出了邻接点的先后顺序，这时深度优先和广度优先遍历序列就是唯一的。
【例6—4】对于如图6—8所示的带权无向图，用图示说明： (1）利用Prim 算法从顶点a 开始构造最小生成树的过程； （2)利用Kruskal 算法构造最小生成树的过程；图6-5 图的邻接表存储3e 1f dc ba g 979 4 6 2 1 85 48 图6-8 带权无向图解:(1）利用Prim 算法从顶点a 开始构造最小生成树的过程如图6—9所示.（2）利用Kruskal 算法构造最小生成树的过程如图6-10所示.a 初始状态ae 连通e2 aeg连通g2 1 aed g连通d2 1 33aefdg 连通f2 1 4 3aef dbg连通b2 1 46图6-9 用Prim 算法构造最小生成树的过程3aef dcbg连通c2 1461a e fd cbg初始状态a efdcbg增加第2条边11a efd cbg增加第1条边1习题6一、单项选择题1。
在具有n 个顶点的有向图中，若所有顶点的出度之和为s ，则所有顶点的入度之和为(A ）。
A 。
sB 。
s-1C 。
s+1D 。
数据结构与算法(13)：深度优先搜索和广度优先搜索
2.2.2 有向图的广广度优先搜索
下面面以“有向图”为例例，来对广广度优先搜索进行行行演示。还是以上面面的图G2为例例进行行行说明。
第1步：访问A。 第2步：访问B。 第3步：依次访问C,E,F。 在访问了了B之后，接下来访问B的出边的另一一个顶点，即C,E,F。前 面面已经说过，在本文文实现中，顶点ABCDEFG按照顺序存储的，因此会先访问C，再依次访 问E,F。 第4步：依次访问D,G。 在访问完C,E,F之后，再依次访问它们的出边的另一一个顶点。还是按 照C,E,F的顺序访问，C的已经全部访问过了了，那么就只剩下E,F；先访问E的邻接点D，再访 问F的邻接点G。
if(mVexs[i]==ch)
return i;
return -1;
}
/* * 读取一一个输入入字符
*/
private char readChar() {
char ch='0';
do {
try {
ch = (char)System.in.read();
} catch (IOException e) {
数据结构与算法（13）：深度优先搜索和 广广度优先搜索
BFS和DFS是两种十十分重要的搜索算法，BFS适合查找最优解，DFS适合查找是否存在解(或者说 能找到任意一一个可行行行解)。用用这两种算法即可以解决大大部分树和图的问题。
一一、深度优先搜索（DFS）
1.1 介绍
图的深度优先搜索（Depth First Search），和树的先序遍历比比较类似。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点V出发，首首先访问该顶点， 然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至至图中所有和V有路路径相通 的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一一个未被访问的顶点作起始点，重 复上述过程，直至至图中所有顶点都被访问到为止止。 显然，深度优先搜索是一一个递归的过程。
数据结构试题及答案修改一
数据结构试卷（一）一、单选题（每题 2 分，共20分）1.栈和队列的共同特点是( A )。
A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.用链接方式存储的队列，在进行插入运算时( D ).A. 仅修改头指针B. 头、尾指针都要修改C. 仅修改尾指针D.头、尾指针可能都要修改3.以下数据结构中哪一个是非线性结构？(D)A. 队列B. 栈C. 线性表D. 二叉树4.设有一个二维数组A[m][n]，假设A[0][0]存放位置在644(10)，A[2][2]存放位置在676(10)，每个元素占一个空间，问A[3][3](10)存放在什么位置？脚注(10)表示用10进制表示。
(C )A．688 B．678 C．692 D．6965.树最适合用来表示( C)。
A.有序数据元素B.无序数据元素C.元素之间具有分支层次关系的数据D.元素之间无联系的数据6.二叉树的第k层的结点数最多为( D ).k-1A．2k-1 B.2K+1 C.2K-1 D. 27.设有6个结点的无向图，该图至少应有( A)条边才能确保是一个连通图。
A.5B.6C.7D.8一、填空题（每空1分，共26分）1.通常从四个方面评价算法的质量：正确性易读性强壮性高效率2.一个算法的时间复杂度为(n3+n2log2n+14n)/n2，其数量级表示为___O(n)__。
3.假定一棵树的广义表表示为A（C，D（E，F，G），H（I，J）），则树中所含的结点数为_9____个，树的深度为__3____，树的度为_3___。
4.后缀算式9 2 3 +- 10 2 / -的值为___-1___。
中缀算式（3+4X）-2Y/3对应的后缀算式为3 4 X * + 2 Y * 3 / -_____________________________。
5.若用链表存储一棵二叉树时，每个结点除数据域外，还有指向左孩子和右孩子的两个指针。
在这种存储结构中，n个结点的二叉树共有____2n ____个指针域，其中有__n-1 ______个指针域是存放了地址，有__________n+1______个指针是空指针。
邻接矩阵表示图-深度-广度优先遍历
*问题描述：建立图的存储结构（图的类型可以是有向图、无向图、有向网、无向网，学生可以任选两种类型），能够输入图的顶点和边的信息，并存储到相应存储结构中，而后输出图的邻接矩阵。
1、邻接矩阵表示法:设G=(V,E)是一个图，其中V={V1,V2,V3…,Vn}。
G的邻接矩阵是一个他有下述性质的n阶方阵：1，若(Vi,Vj)∈E 或<Vi,Vj>∈E；A[i,j]={0，反之图5-2中有向图G1和无向图G2的邻接矩阵分别为M1和M2:M1=┌0 1 0 1 ┐│ 1 0 1 0 ││ 1 0 0 1 │└0 0 0 0 ┘M2=┌0 1 1 1 ┐│ 1 0 1 0 ││ 1 1 0 1 │└ 1 0 1 0 ┘注意无向图的邻接是一个对称矩阵，例如M2。
用邻接矩阵表示法来表示一个具有n个顶点的图时，除了用邻接矩阵中的n*n个元素存储顶点间相邻关系外，往往还需要另设一个向量存储n个顶点的信息。
因此其类型定义如下：VertexType vertex[MAX_VERTEX_NUM]; // 顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志若图中每个顶点只含一个编号i(1≤i≤vnum)，则只需一个二维数组表示图的邻接矩阵。
此时存储结构可简单说明如下：type adjmatrix=array[1..vnum,1..vnum]of adj;利用邻接矩阵很容易判定任意两个顶点之间是否有边（或弧）相联，并容易求得各个顶点的度。
对于无向图，顶点Vi的度是邻接矩阵中第i行元素之和，即n nD(Vi)＝∑A[i,j]（或∑A[i,j]）j=1 i=1对于有向图，顶点Vi的出度OD(Vi)为邻接矩阵第i行元素之和，顶点Vi 的入度ID(Vi)为第i列元素之和。
即n nOD(Vi)＝∑A[i,j]，OD(Vi)＝∑A[j,i]）j=1j=1用邻接矩阵也可以表示带权图，只要令Wij, 若<Vi,Vj>或(Vi,Vj)A[i,j]＝{∞, 否则。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验报告◎实验题目:无序图的存储并分别实现深度和广度优先遍历◎实验目的：理解并掌握以邻接表的方式存储图，以及图的非递归的深度和广度优先遍历◎实验内容：首先将图的元素输入并以邻接表的方式存储，然后分别进行递归和非递归遍历。
一、需求分析1、输入的形式和输入值的范围：①输入图的顶点元素和边；②输入数字选择要进行的操作：深度遍历，广度遍历或结束操作。
2、输出的形式:按深度或者广度优先顺序输出各节点的编号3、程序所能达到的功能：（1）以邻接表的方式存储图（2）对图进行深度优先的非递归遍历（3）对图进行广度优先的非递归遍历4、测试数据：输入各结点元素：a,b,c,d,e,f,g,h；输入图中的各边：1,2 1,3 2,4 2,5 3,6 3,7 4,8 5,8操作选项输入1进行深度优先遍历；遍历结果为：1 3 7 6 2 5 8 4操作选项输入2进行广度优先遍历；遍历结果为：1 3 2 7 6 5 4二概要设计（1）抽象数据类型定义：#define MaxVerNum 100//边表结点typedef struct node{int adjvex;struct node *next;}EdgeNode,*ENode;顶点表结点；typedef struct vnode{char vertex;EdgeNode *firstedge;}VertexNode;typedef VertexNode AdjList[MaxVerNum];定义图；typedef struct{AdjList adjlist;int n,e;}AlGraph;AlGraph G;（2）主程序的流程：1.根据提示输入顶点个数和边的个数；2.输入图的各边；3. 输入数字执行相关操作（3）其函数之间调用关系如下：执行结束后，重新执行判定操作和循环。
三详细设计1.元素类型#define MaxVerNum 100typedef struct node{int adjvex;struct node *next;}EdgeNode,*ENode;typedef struct vnode{char vertex;EdgeNode *firstedge;}VertexNode;typedef VertexNode AdjList[MaxVerNum];typedef struct{AdjList adjlist;int n,e;}AlGraph;AlGraph G;2．每个模块的分析：（1）主程序模块：int main(){int a,v;//创建图Create(G);printf("请选择要进行的操作：\n 选择深度优先请输入1；\n 选择广度优先请输入2；\n结束操作请输入0\n");scanf("%d",&a);while(a!=0){printf("请输入开始遍历顶点的坐标\n");scanf("%d",&v);if(a==1)//深度优先遍历DfsTravel(G,v);}else if(a==2)//广度优先遍历{ BfsTravel(G,v);}printf("请选择要进行的操作：\n 选择深度优先请输入1；\n 选择广度优先请输入2；\n结束操作请输入0\n");scanf("%d",&a);}return 0;}（2）深度优先遍历void DfsTravel(AlGraph &G,int v){ENode stack[MaxVerNum];ENode p;int visited[MaxVerNum],top=-1,i;for(i=0;i<G.n;i++)visited[i]=0;printf("深度优先遍历的结果为：\n");printf("%d ",v);visited[v]=1;p=G.adjlist[v].firstedge;while(top!=-1||p!=NULL){while(p!=NULL){if(visited[p->adjvex]==1)p=p->next;else{printf("%d ",p->adjvex);visited[p->adjvex]=1;top++;stack[top]=p;p=G.adjlist[p->adjvex].firstedge;}}if(top!=-1){ p=stack[top];top--;p=p->next;}}printf("\n");}（3）广度优先遍历void BfsTravel(AlGraph &G,int v){int visited[MaxVerNum];int queue[MaxVerNum];int front=-1,rear=-1;EdgeNode *p;int i;for(i=0;i<G.n;i++)visited[i]=0;printf("广度优先遍历的结果为：\n");printf("%d ",v);visited[v]=1;rear=rear+1;queue[rear]=v;while(front!=rear){front++;v=queue[front];p=G.adjlist[v].firstedge;while(p!=NULL){if(visited[p->adjvex]==0){printf("%d ",p->adjvex); visited[p->adjvex]=1;rear=rear+1;queue[rear]=p->adjvex;}p=p->next;}}printf("\n");}(4)创建图void Create(AlGraph &G){int i,j,k;EdgeNode *s,*r;printf("请依次输入无向图顶点个数和边的个数\n");scanf("%d,%d",&(G.n),&(G.e));getchar();printf("请输入各顶点信息\n");for(i=0;i<G.n;i++){scanf("%c",&(G.adjlist[i].vertex));getchar();G.adjlist[i].firstedge=NULL;}printf("请输入各边的信息，输入格式为i,j\n");for(k=0;k<G.e;k++){scanf("%d,%d",&i,&j);s=(EdgeNode*)malloc(sizeof(EdgeNode));s->adjvex=j;s->next= G.adjlist[i].firstedge;G.adjlist[i].firstedge=s;r=(EdgeNode*)malloc(sizeof(EdgeNode));r->adjvex=i;r->next= G.adjlist[j].firstedge;G.adjlist[j].firstedge=r;}}四使用说明、测试分析及结果输入各结点元素：a,b,c,d,e,f,g,h；输入图中的各边：1,2 1,3 2,4 2,5 3,6 3,7 4,8 5,8操作选项输入1进行深度优先遍历；遍历结果为：1 3 7 6 2 5 8 4操作选项输入2进行广度优先遍历；遍历结果为：1 3 2 7 6 5 41.程序使用说明；（1）本程序的运行环境为VC6.0。
（2）进入演示程序后即显示提示信息：请输入顶点个数和边的个数：2、测试结果与分析；输入各结点元素：a,b,c,d,e,f,g,h；输入图中的各边：1,2 1,3 2,4 2,5 3,6 3,7 4,8 5,8操作选项输入1进行深度优先遍历；遍历结果为：1 3 7 6 2 5 8 4操作选项输入2进行广度优先遍历；遍历结果为：1 3 2 7 6 5 43、运行界面。
五、教师评语：实验成绩：指导教师签名：批阅日期：欢迎您的下载，资料仅供参考！致力为企业和个人提供合同协议，策划案计划书，学习资料等等打造全网一站式需求。