数据结构与算法实验报告 图的深度优先与广度优先遍历
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法1. 深度优先搜索（DFS）深度优先搜索是一种常用的图遍历算法，其基本思想是从一个顶点出发，沿着一条路径向来向下访问，直到无法继续为止，然后回溯到前一个顶点，再选择此外一条路径继续访问。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问。
（2）从v出发，选择一个未被访问的邻接顶点w，将w标记为已访问，并将w入栈。
（3）如果不存在未被访问的邻接顶点，则出栈一个顶点，继续访问其它未被访问的邻接顶点。
（4）重复步骤（2）和（3），直到栈为空。
2. 广度优先搜索（BFS）广度优先搜索是另一种常用的图遍历算法，其基本思想是从一个顶点出发，挨次访问其所有邻接顶点，然后再挨次访问邻接顶点的邻接顶点，以此类推，直到访问完所有顶点。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问，并将v入队。
（2）从队首取出一个顶点w，访问w的所有未被访问的邻接顶点，并将这些顶点标记为已访问，并将它们入队。
（3）重复步骤（2），直到队列为空。
三、图的遍历应用图的遍历算法在实际应用中有广泛的应用，下面介绍两个典型的应用场景。
1. 连通分量连通分量是指图中的一个子图，其中的任意两个顶点都是连通的，即存在一条路径可以从一个顶点到达另一个顶点。
图的遍历算法可以用来求解连通分量的个数及其具体的顶点集合。
具体步骤如下：（1）对图中的每一个顶点进行遍历，如果该顶点未被访问，则从该顶点开始进行深度优先搜索或者广度优先搜索，将访问到的顶点标记为已访问。
（2）重复步骤（1），直到所有顶点都被访问。
2. 最短路径最短路径是指图中两个顶点之间的最短路径，可以用图的遍历算法来求解。
数据结构中图的建立与深度优先、广度优先遍历
数据结构中图的建立与深度优先、广度优先遍历《数据结构》实验报告实验内容：图的建立（邻接矩阵）及其深度优先、广度优先遍历学号：姓名：一、上机实验的问题和要求（需求分析）：[ 题目]二、程序设计的基本思想，原理和算法描述：设计一个程序，建立图的邻接矩阵，并且进行图的广度优先遍历。
三、调试和运行程序过程中产生的问题及采取的措施：（略）四、源程序及注释[ 源程序] 程序名：9.cpp#include"stdio.h"#include"stdlib.h"#define INFINITY 100#define MAX_VERTEX_NUM 20#define MAX 100#define OK 1#define ERROR 0#define NULL 0typedef int VRType;typedef int VertextType;typedef int Status;typedef enum {DG,DN,UDG,UDN}GraphKind;typedef struct ArcCell{VRType adj;}ArcCell,AdjMatrix[MAX_VERTEX_NUM ][MAX_VERTEX_NUM ]; typedef struct{int vexs[MAX_VERTEX_NUM ];int arcs[4][4] ;int vexnum,arcnum;GraphKind Kind;}MGraph;int LocateVex(MGraph G,int v1){ int i;for(i=0;i<g.vexnum;i++)< p="">if(G.vexs[i]==v1)printf("%d\n",i);return i;}Status CreateUDN(MGraph &G){ int v1,v2;int i,j,k,w;printf("输入图的顶点数和弧数：");scanf("%d,%d",&G.vexnum,&G.arcnum); printf("输入顶点:");for(i=0;i<g.vexnum;i++)< p="">scanf("%d",&G.vexs[i]);for(i=0;i<g.vexnum;i++)< p="">for(j=0;j<g.vexnum;j++)< p="">G.arcs[i][j]=INFINITY ;printf("输入顶点关系：");for(k=0;k<g.arcnum;k++)< p="">{scanf("%d%d%d",&v1,&v2,&w);i=LocateVex(G,v1);j=LocateVex(G,v2);G.arcs[i][j]=w;G.arcs[j][i]=G.arcs[i][j];printf("%d\n%d\n",G.arcs[i][j],G.arcs[j][i]);}printf("图的邻接矩阵图是:\n");for(i=0;i<g.vexnum;i++)< p="">{for(j=0;j<g.vexnum;j++)< p="">printf("%d",G.arcs[i][j]);printf("\n");}return OK;}Status Visit(int e){//输出函数printf("%d\n",e);return OK;}//PrintElement//Status(*VisitFunc)(char v);int visited[MAX];void DFS(MGraph G,int v){ int j;Visit (v);visited[v]=1;for(j=1;j<g.vexnum;j++)< p="">if(!visited[j]&&G.arcs[v][j]!=INFINITY)DFS(G,j); } void DFSTraverse(MGraph G){ int v;for(v=0;v<g.vexnum;++v)< p="">visited[v]=0;for(v=0;v<g.vexnum;++v)< p="">if(!visited[v])DFS(G,v);/* 有关队列的操作*/#define MAX SIZE 100#define QElemType int#define OVERFLOW 0typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue(SqQueue &Q){ Q.base=(QElemType*)malloc(MAXSIZE* sizeof(QElemType)); if(!Q.base)exit(OVERFLOW);Q.front=Q.rear=0;return 0;}Status EnQueue(SqQueue &Q,QElemType e){if(Q.rear+1==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=Q.rear+1;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=Q.front+1;return OK;}Status QueueEmpty(SqQueue Q){if(Q.front==Q.rear)return OK;else return ERROR;void BFSTraverse(MGraph &G){ int v,u,j;SqQueue Q;for(v=0;v<g.vexnum;v++)< p=""> visited[v]=0;InitQueue(Q);for(v=0;v<g.vexnum;++v)< p="">if(!visited[v]){visited[v]=1;Visit(v);EnQueue(Q,v);while(!QueueEmpty(Q)){ DeQueue(Q,u);for(j=1;j<g.vexnum;j++)< p="">if(!visited[j]&&G.arcs[v][j]!=INFINITY) { visited[j]=1;Visit(j);EnQueue(Q,j);}} }}void main(){ MGraph G;CreateUDN(G);printf("建图成功！");printf("深度优先遍历的结果:\n"); DFSTraverse(G);printf("广度优先遍历的结果:\n"); BFSTraverse(G);}五、运行结果运行结果：上一页下一页</g.vexnum;j++)<></g.vexnum;++v)<></g.vexnum;v++)<></g.vexnum;++v)<> </g.vexnum;++v)<> </g.vexnum;j++)<> </g.vexnum;j++)<> </g.vexnum;i++)<> </g.arcnum;k++)<> </g.vexnum;j++)<> </g.vexnum;i++)<> </g.vexnum;i++)<> </g.vexnum;i++)<>。
图的遍历 实验报告
图的遍历实验报告一、引言图是一种非线性的数据结构，由一组节点（顶点）和节点之间的连线（边）组成。
图的遍历是指按照某种规则依次访问图中的每个节点，以便获取或处理节点中的信息。
图的遍历在计算机科学领域中有着广泛的应用，例如在社交网络中寻找关系紧密的人员，或者在地图中搜索最短路径等。
本实验旨在通过实际操作，掌握图的遍历算法。
在本实验中，我们将实现两种常见的图的遍历算法：深度优先搜索（DFS）和广度优先搜索（BFS），并比较它们的差异和适用场景。
二、实验目的1. 理解和掌握图的遍历算法的原理与实现；2. 比较深度优先搜索和广度优先搜索的差异；3. 掌握图的遍历算法在实际问题中的应用。
三、实验步骤实验材料1. 计算机；2. 编程环境（例如Python、Java等）；3. 支持图操作的相关库（如NetworkX）。
实验流程1. 初始化图数据结构，创建节点和边；2. 实现深度优先搜索算法；3. 实现广度优先搜索算法；4. 比较两种算法的时间复杂度和空间复杂度；5. 比较两种算法的遍历顺序和适用场景；6. 在一个具体问题中应用图的遍历算法。
四、实验结果1. 深度优先搜索（DFS）深度优先搜索是一种通过探索图的深度来遍历节点的算法。
具体实现时，我们可以使用递归或栈来实现深度优先搜索。
算法的基本思想是从起始节点开始，选择一个相邻节点进行探索，直到达到最深的节点为止，然后返回上一个节点，再继续探索其他未被访问的节点。
2. 广度优先搜索（BFS）广度优先搜索是一种逐层遍历节点的算法。
具体实现时，我们可以使用队列来实现广度优先搜索。
算法的基本思想是从起始节点开始，依次遍历当前节点的所有相邻节点，并将这些相邻节点加入队列中，然后再依次遍历队列中的节点，直到队列为空。
3. 时间复杂度和空间复杂度深度优先搜索和广度优先搜索的时间复杂度和空间复杂度如下表所示：算法时间复杂度空间复杂度深度优先搜索O(V+E) O(V)广度优先搜索O(V+E) O(V)其中，V表示节点的数量，E表示边的数量。
图的深度和广度遍历-实验报告
实验报告一、实验目的和内容1.实验目的掌握图的邻接矩阵的存储构造；实现图的两种遍历：深度优先遍历和广度优先遍历。
2.实验内容1．图的初始化；2．图的遍历：深度优先遍历和广度优先遍历。
二、实验方案程序主要代码：///<summary>///邻接矩阵的节点数据///</summary>public struct ArcCell{public int Type; //顶点的关系类型，对无权图，用1或0表示相邻；//对带权图，那么为权值类型。
public object Data; //该弧相关信息public ArcCell(int type,object data){Type = type;Data = data;}}///<summary>///图的类型///</summary>public enum GKind {DG,DN,UDG,UDN}; //有向图，有向网，无向图，无向网///<summary>///图类///</summary>public class Graph{public static int Max_Vertex_Num = 20; //最大顶点数private object [] Vexs; //顶点数据数组private ArcCell [,] Arcs; //邻接矩阵private GKind Kind; //图的种类private int VexNum,ArcNum; //当前顶点数和弧数///<summary>///图的初始化方法///</summary>///<param name="vexnum">顶点数</param>///<param name="arcnum">弧数</param>///<param name="k">图的类型</param>public Graph(int vexnum,int arcnum,GKind k){VexNum = vexnum;ArcNum = arcnum;Kind = k;Vexs = new object[Max_Vertex_Num];Arcs = new ArcCell[Max_Vertex_Num,Max_Vertex_Num];}///<summary>///设置v1，v2之间的弧的权值，顶点的关系类型，对无权图，用1或0表示相邻；///对带权图，那么为权值类型。
实验三 图的广度优先遍历和深度优先遍历算法的设计
实验三 图的广度优先遍历和深度优先遍历算法的设计一、实验目的本实验的目的是通过理解图的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。
二、实验内容１．分别编写BFS 、DFS 算法。
2．判断无向图G 是否连通，若连通则返回1，否则返回0。
3．判断无向图G 是否是一棵树。
若是树，返回1；否则返回0。
4．判断有向图中是否存在回路。
5．假设图G 采用邻接表存储，求距离顶点vO 的最短路径长度为k 的所有顶点，要求尽可能节省 时间。
三、实验类型验证性四、实验要求和提示1．实验前充分预习实验指导书内容及相关理论知识内容：实验中严格遵守实验室规范和制度，认真完成实验内容并做好实验纪录：实验后必须按照要求独立完成实验报告。
2．以上6个题中，题1是必做题，题2—5可任意选作l 或2题。
3．提示：（1）最好使用邻接表法建立无向图和有向图的存储结构，然后实现图的遍历。
（2）结点结构：typedef struct node{ int adjvex ； //邻接点域，存放与Vi 邻接的结点在表头数组中的位置 struct node * next ； //链域，指示下一条边或弧)JD ：表头接点：typedef struct tnode{ int vexdata ；//存放顶点信息struct node *firstarc ；//指示第一个邻接点}TD ；4．程序实现方面的提示：（1）可采用遍历方式判断无向图是否连通。
先给visited[]数组置初值O，然后从O 开始遍历该图，之后若所有顶点i的visited[i]均为1，则该图是连通的，否则不连通。
（2）一个无向图G是一棵树的条件是：G必须是无回路的连通图或者是有n—l条边的连通图(注：本题可以只给出算法)（3）判断有向图中是否存在回路时，若一个有向图拓扑排序不成功，则一定存在回路；反之，若拓扑排序成功，则一定不存在回路。
（3）采用宽度优先搜索方法，找出第k层的所有顶点即为所求(宽度优先搜索保证找到的路径是最短路径)。
图的深度优先遍历和广度优先遍历
华北水利水电学院数据结构实验报告20 10 ～20 11 学年第一学期2008级计算机专业班级：107学号：200810702姓名：王文波实验四图的应用一、实验目的：1．掌握图的存储结构及其构造方法2．掌握图的两种遍历算法及其执行过程二、实验内容：以邻接矩阵或邻接表为存储结构，以用户指定的顶点为起始点，实现无向连通图的深度优先及广度优先搜索遍历，并输出遍历的结点序列。
提示：首先，根据用户输入的顶点总数和边数，构造无向图，然后以用户输入的顶点为起始点，进行深度优先和广度优先遍历，并输出遍历的结果。
三、实验要求：1．各班学号为单号的同学采用邻接矩阵实现，学号为双号的同学采用邻接表实现。
2．C/ C++完成算法设计和程序设计并上机调试通过。
3．撰写实验报告，提供实验结果和数据。
4．写出算法设计小结和心得。
四、程序源代码：#include<iostream.h>#define MaxVerNum 50struct edgenode{int endver;int inform;edgenode* edgenext;};struct vexnode{char vertex;edgenode* edgelink;};struct Graph{vexnode adjlists[MaxVerNum];int vexnum;int arcnum;};//队列的定义及相关函数的实现struct QueueNode{int nData;QueueNode* next;};struct QueueList{QueueNode* front;QueueNode* rear;};void EnQueue(QueueList* Q,int e) {QueueNode *q=new QueueNode;q->nData=e;q->next=NULL;if(Q==NULL)return;if(Q->rear==NULL)Q->front=Q->rear=q;else{Q->rear->next=q;Q->rear=Q->rear->next;}}void DeQueue(QueueList* Q,int* e) {if (Q==NULL)return;if (Q->front==Q->rear){*e=Q->front->nData;Q->front=Q->rear=NULL;}else{*e=Q->front->nData;Q->front=Q->front->next;}}//创建图void CreatAdjList(Graph* G){int i,j,k;edgenode* p1;edgenode* p2;cout<<"请输入顶点数和边数:"<<endl;cin>>G->vexnum>>G->arcnum;cout<<"开始输入顶点表:"<<endl;for (i=0;i<G->vexnum;i++){cin>>G->adjlists[i].vertex;G->adjlists[i].edgelink=NULL;}cout<<"开始输入边表信息:"<<endl;for (k=0;k<G->arcnum;k++){cout<<"请输入边<Vi,Vj>对应的顶点:";cin>>i>>j;p1=new edgenode;p1->endver=j;p1->edgenext=G->adjlists[i].edgelink;G->adjlists[i].edgelink=p1;p2=new edgenode;p2->endver=i;p2->edgenext=G->adjlists[j].edgelink;G->adjlists[j].edgelink=p2;//因为是无向图，所以有两次建立边表的过程}}//-------------------------------------------------------------深度优先遍历void DFS(Graph *G,int i,int visit[]){cout<<G->adjlists[i].vertex<<" ";visit[i]=1;edgenode *p=new edgenode;p=G->adjlists[i].edgelink;if(G->adjlists[i].edgelink&&!visit[p->endver]){DFS(G,p->endver,visit);}}void DFStraversal(Graph *G,char c)//深度优先遍历{cout<<"该图的深度优先遍历结果为:"<<endl;int visit[MaxVerNum];for(int i=0;i<G->vexnum;i++){visit[i]=0;//全部初始化为0，即未访问状态}int m;for (i=0;i<G->vexnum;i++){if (G->adjlists[i].vertex==c)//根据字符查找序号{m=i;DFS(G,i,visit);break;}}//继续访问未被访问的结点for(i=0;i<G->vexnum;i++){if(visit[i]==0)DFS(G,i,visit);}cout<<endl;}//-------------------------------------------------------------广度优先遍历void BFS(Graph* G,int v,int visit[]){QueueList *Q=new QueueList;Q->front=Q->rear=NULL;EnQueue(Q,v);while(Q->rear!=NULL){int e=0;DeQueue(Q,&e);cout<<G->adjlists[e].vertex<<" ";visit[e]=1;edgenode* p=new edgenode;p=G->adjlists[e].edgelink;if(p){int m=p->endver;if(m==0){EnQueue(Q,m);while(visit[m]==0){p=p->edgenext;if(p==NULL)break;m=p->endver;EnQueue(Q,m);}}}}}void BFStraversal(Graph *G,char c){cout<<"该图的广度优先遍历结果为:"<<endl;int visited[MaxVerNum];for (int i=0;i<G->vexnum;i++){visited[i]=0;}int m;for (i=0;i<G->vexnum;i++){if (G->adjlists[i].vertex==c){m=i;BFS(G,i,visited);break;}}//继续访问未被访问的结点for(i=0;i<G->vexnum;i++){if(visited[i]==0)BFS(G,i,visited);}cout<<endl;}void main(){Graph * G=new Graph;CreatAdjList(G);char ch;cout<<"请输入开始遍历的顶点:";cin>>ch;DFStraversal(G,ch);BFStraversal(G,ch);}五、程序运行情况（写出输入数据及运行结果）六、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）注：内容一律使用宋体五号字，单倍行间距本次试验采用的是邻接表的方式实现图的深度优先遍历和广度优先遍历。
实验四图的应用深度优先广度优先搜索遍历
数据结构实验报告实验四图的应用一、实验题目：图的应用——深度优先／广度优先搜索遍历二、实验内容：很多涉及图上操作的算法都是以图的遍历操作为基础的。
试编写一个算法，实现图的深度优先和广度优先搜索遍历操作。
要求：以邻接矩阵或邻接表为存储结构，以用户指定的顶点为起始点，实现连通无向图的深度优先及广度优先搜索遍历，并输出遍历的结点序列。
（注：学号为奇数的同学使用邻接矩阵存储结构实现，学号为偶数的同学使用邻接矩阵实现）提示：首先，根据用户输入的顶点总数和边数，构造无向图，然后以用户输入的顶点为起始点，进行深度优先、广度优先搜索遍历，并输出遍历的结果。
三、程序源代码：#include<stdio.h>#include<stdlib.h>#define MAX_VERTEX_NUM 20#define OVERFLOW -1int visited[80];typedef struct ArcNode{int adjvex; //该弧所指向的顶点的位置struct ArcNode *nextarc; //指向下一条弧的指针}ArcNode;typedef struct VNode{int data; //顶点信息ArcNode *firstarc; //指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;//图的当前顶点数和弧数}ALGraph;typedef struct QNode{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;void InitQueue(LinkQueue &q){//构造一个空队列qq.front=q.rear=(QueuePtr)malloc(sizeof(QNode));if(!q.front) exit(OVERFLOW);q.front->next=NULL;}void EnQueue(LinkQueue &q,int e){//插入元素e为q的新的队尾元素QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);//存储分配失败p->data=e;p->next=NULL;q.rear->next=p;q.rear=p;}int DeQueue(LinkQueue &q){int e;//若队列不空，则删除q的队头元素，用e返回其值，并返回OK;否则返回ERROR if(q.front==q.rear) return false;QueuePtr p;p=q.front->next;e=p->data;q.front->next=p->next;if(q.rear==p) q.rear=q.front;free(p);return e;}bool QueueEmpty(LinkQueue &q){ //若队列q为空队列，则返回TRUE，否则返回FLASE if(q.front==q.rear) return true;elsereturn false;}int LocateVex(ALGraph G,int v){int i;for(i=0;i<G.vexnum;i++)if(G.vertices[i].data==v)return i;}//用邻接表构造无向图void CreateDG(ALGraph &G){int i,j,k;printf("输入图的顶点数和弧度:\n");scanf("%d %d",&G.vexnum,&G.arcnum);printf("输入顶点信息:\n");for(i=0;i<G.vexnum;i++){scanf("%d",&G.vertices[i].data);G.vertices[i].firstarc=NULL;}printf("输入邻接点:\n");for(k=0;k<G.arcnum;k++){char v1,v2;scanf("%d %d",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);struct ArcNode *s;s=(ArcNode *)malloc(sizeof(ArcNode));s->adjvex=j;s->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=s;struct ArcNode *t;t=(ArcNode *)malloc(sizeof(ArcNode));t->adjvex=i;t->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=t;}}void DFSAL(ALGraph G,int v0){visited[v0]=1;printf("%5d",G.vertices[v0].data);struct ArcNode *p;int w;for(p=G.vertices[v0].firstarc;p;p=p->nextarc){w=p->adjvex;if(!visited[w])DFSAL(G,w);}}//深度优先搜索遍历void DFSTraverse(ALGraph G){int v0;for(v0=0;v0<G.vexnum;v0++) visited[v0]=0; //访问标志数组初始化//直到图中所有顶点都被访问到为止for(v0=0;v0<G.vexnum;v0++)if(!visited[v0])DFSAL(G,v0); //对尚未访问的顶点调用DFSAL}//广度优先搜索遍历void BFSTraverse(ALGraph G,LinkQueue q){ int u,w;struct ArcNode *p;for(u=0;u<G.vexnum;u++) visited[u]=0; //访问标志数组初始化InitQueue(q);for(u=0;u<G.vexnum;u++)if(!visited[u]){printf("%5d",G.vertices[u].data);visited[u]=1;EnQueue(q,u);while(!QueueEmpty(q)){u=DeQueue(q);p=G.vertices[u].firstarc;while(p){w=p->adjvex;if(!visited[w]){visited[w]=1;printf("%5d",G.vertices[w].data);EnQueue(q,w);}//ifp=p->nextarc;}//while}//while}//if}//BFSTraverseint main(){ALGraph G;LinkQueue q;CreateDG(G);printf("\n");printf("输出深度优先搜索序列：\n");DFSTraverse(G);printf("\n");printf("输出广度优先搜索序列：\n");BFSTraverse(G,q);printf("\n");return 0;}四、测试结果：。
实验四：图的深度优先与广度优先遍历
实验报告学院（系）名称：计算机与通信工程学院一、实验目的理解图的逻辑特点；掌握理解图的两种主要存储结构（邻接矩阵和邻接表），掌握图的构造、深度优先遍历、广度优先遍历算法二、实验题目与要求1. 每位同学按下述要求实现相应算法：根据从键盘输入的数据创建图（图的存储结构可采用邻接矩阵或邻接表），并对图进行深度优先搜索和广度优先搜索1）问题描述：在主程序中提供下列菜单：1…图的建立2…深度优先遍历图3…广度优先遍历图0…结束2）实验要求：图的存储可采用邻接表或邻接矩阵；定义下列过程：CreateGraph(): 按从键盘的数据建立图DFSGrahp()：深度优先遍历图BFSGrahp()：广度优先遍历图3）实验提示:图的存储可采用邻接表或邻接矩阵；图存储数据类型定义（邻接表存储）# define MAX_VERTEX_NUM 8 拓扑排序：给出一个图的结构，输出其拓扑排序序列（顶点序列用空格隔开），要求在同等条件下，编号小的顶点在前。
3．利用最小生成树算法解决通信网的总造价最低问题1）问题描述：若在 n 个城市之间建通信网络，架设 n-1 条线路即可。
如何以最低的经济代价建设这个通信网，是一个网络的最小生成树问题。
2）实验要求：利用 Prim 算法求网的最小生成树。
3) 实现提示：通信线路一旦建立，必然是双向的。
因此，构造最小生成树的网一定是无向网。
为简单起见，图的顶点数不超过 10 个，网中边的权值设置成小于 100。
三、实验过程与实验结果应包括如下主要内容：数据结构定义图是由定点集合及定点间的关系集合组成的一种数据结构，其形式化定义为Graph = （V，E）其中，V = {x|x∈某个数据对象}是定点的有限非空集合；E = {（x,y）|x,y∈V∧Path(x,y)}是顶点之间关系的有限集合，叫做便集。
集合E中的Path（x,y）表示顶点x和顶点y之间有一条直接连线，即（x,y）表示一条边，它是有方向的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
visit(w);
EnQueue(q,w);
visited[w]=1;
}
w=NextAdj(g,v);
}
}
}
void Travel_BFS(VNode g[],int visited[],int n){
int i;
for(i=0;i<n;i++){
visited[i]=0;
vertexType data;
Arcnode *firstarc;
}VNode;
//VNode G[MAX_VERTEX_NUM];
void getdata(VNode v);
//图的创建
void createGraph(int n,VNode G[]){
int i,e;
Arcnode *p,*q;
scanf("%d",&e);
while(e!=-1){
p=(Arcnode *)malloc(sizeof(Arcnode));
p->next=NULL;
p->adjvex=e;
if(G[i].firstarc==NULL){
G[i].firstarc=p;
}else{
q->next=p;
}
q=p;
}
}
//图的遍历(2)--广度优先搜索
void BFS(VNode G[],int v,int visited[]){
int w;
visit(v);
visited[v]=1;
EnQueue(q,v);
while(!emptyA(q)){
Dequeue(&q,&v);
w=FirstAdj(g,v);
while(w!=-1){
w=nextAdj(g,v);
}
}
void DFSGraph(VNode g[],int visited[],int n){
int i;
for(i=0;i<n;i++){
visited[i]=0;
}
for(i=0;i<n;i++){
if(visited[i]==0)
DFS(g,i,visited);
二、实验题目与要求
图的遍历
利用邻接矩阵或邻接表作为存储结构建立一个无向图，每个顶点中存放一种水果名(例如apple、orange、banana等，并要求从键盘输入)，顶点数不少于5个。要求分别以深度优先搜索(DFS)和广度优先搜索(BFS)进行遍历，输出遍历结果。
三、源代码清单
=#include<stdlib.h>
}
for(i=0;i<n;i++){
if(visited[i]==0)
BFS(g,i,visited);
}
}
实验心得：
通过本次实验，我理解图的逻辑特点，理解图的邻接矩阵或邻接表存储结构，掌握图的深度优先遍历、广度优先遍历算法。实验中遇到了很多问题，通过与同学交流沟通，最终完成了本次实验，希望以后能再接再厉。
#define MAX_VERTEX_NUM;
typedef int infoType;
typedef int vertexType;
typedef struct ArcNode{
int adjvex;
struct ArcNode *next;
infoType *weight;
}Arcnode;
typedef struct VNode{
printf("input the information of the vertex\n");
for(i=0;i<n;i++){
getdata(G[i]);
G[i].firstarc=NULL;
}
for(i=0;i<n;i++){
printf("create the edges for the %dth vertex\n",i);
scanf("%d",&e);
}
}
}
//图的遍历(1)--深度优先搜索
void DFS(VNode g[],int v,int visited[]){
int w;
visit(v);
visited[v]=1;
w=FirstAdj(g,v);
while(w!=-1){
if(visited[w]==0)
DFS(g,w,visited);
实验报告学院（系）名Fra bibliotek：计算机与通信工程学院
姓名
学号
专业
计算机科学与技术
班级
实验项目
实验四：图的深度优先与广度优先遍历
课程名称
数据结构与算法
课程代码
0661913
实验时间
2019年4月26日 第1-2节
实验地点
7-219
考核标准
实验过程
25分
程序运行
20分
回答问题
15分
实验报告
30分
特色
功能
5分
考勤违纪情况
5分
成绩
成绩栏
其它批改意见:
教师签字：
考核内容
评价在实验课堂中的表现，包括实验态度、编写程序过程等内容等。
□功能完善,
□功能不全
□有小错
□无法运行
○正确
○基本正确
○有提示
○无法回答
○完整
○较完整
○一般
○内容极少
○无报告
○有
○无
○有
○无
一、实验目的
理解图的逻辑特点，理解图的邻接矩阵或邻接表存储结构，掌握图的深度优先遍历、广度优先遍历算法。