实验四----图的遍历与应用(广度优先遍历)

合集下载

图的深度和广度遍历-实验报告

图的深度和广度遍历-实验报告

实验报告一、实验目的和内容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表示相邻;///对带权图,那么为权值类型。

图的遍历操作实验报告

图的遍历操作实验报告

-实验三、图的遍历操作一、目的掌握有向图和无向图的概念;掌握邻接矩阵和邻接链表建立图的存储构造;掌握DFS及BFS对图的遍历操作;了解图构造在人工智能、工程等领域的广泛应用。

二、要求采用邻接矩阵和邻接链表作为图的存储构造,完成有向图和无向图的DFS 和BFS操作。

三、DFS和BFS 的根本思想深度优先搜索法DFS的根本思想:从图G中*个顶点Vo出发,首先访问Vo,然后选择一个与Vo相邻且没被访问过的顶点Vi访问,再从Vi出发选择一个与Vi相邻且没被访问过的顶点Vj访问,……依次继续。

如果当前被访问过的顶点的所有邻接顶点都已被访问,则回退到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W,从W出发按同样方法向前遍历。

直到图中所有的顶点都被访问。

广度优先算法BFS的根本思想:从图G中*个顶点Vo出发,首先访问Vo,然后访问与Vo相邻的所有未被访问过的顶点V1,V2,……,Vt;再依次访问与V1,V2,……,Vt相邻的起且未被访问过的的所有顶点。

如此继续,直到访问完图中的所有顶点。

四、例如程序1.邻接矩阵作为存储构造的程序例如#include"stdio.h"#include"stdlib.h"#define Ma*Verte*Num 100 //定义最大顶点数typedef struct{char ve*s[Ma*Verte*Num]; //顶点表int edges[Ma*Verte*Num][Ma*Verte*Num]; //邻接矩阵,可看作边表int n,e; //图中的顶点数n和边数e}MGraph; //用邻接矩阵表示的图的类型//=========建立邻接矩阵=======void CreatMGraph(MGraph *G){int i,j,k;char a;printf("Input Verte*Num(n) and EdgesNum(e): ");scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数scanf("%c",&a);printf("Input Verte* string:");for(i=0;i<G->n;i++){scanf("%c",&a);G->ve*s[i]=a; //读入顶点信息,建立顶点表}for(i=0;i<G->n;i++)for(j=0;j<G->n;j++)G->edges[i][j]=0; //初始化邻接矩阵printf("Input edges,Creat Adjacency Matri*\n");for(k=0;k<G->e;k++) { //读入e条边,建立邻接矩阵 scanf("%d%d",&i,&j); //输入边〔Vi,Vj〕的顶点序号G->edges[i][j]=1;G->edges[j][i]=1; //假设为无向图,矩阵为对称矩阵;假设建立有向图,去掉该条语句}}//=========定义标志向量,为全局变量=======typedef enum{FALSE,TRUE} Boolean;Boolean visited[Ma*Verte*Num];//========DFS:深度优先遍历的递归算法======void DFSM(MGraph *G,int i){ //以Vi为出发点对邻接矩阵表示的图G进展DFS搜索,邻接矩阵是0,1矩阵 int j;printf("%c",G->ve*s[i]); //访问顶点Vivisited[i]=TRUE; //置已访问标志for(j=0;j<G->n;j++) //依次搜索Vi的邻接点if(G->edges[i][j]==1 && ! visited[j])DFSM(G,j); //〔Vi,Vj〕∈E,且Vj未访问过,故Vj为新出发点}void DFS(MGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)if(!visited[i]) //Vi未访问过DFSM(G,i); //以Vi为源点开场DFS搜索}//===========BFS:广度优先遍历=======void BFS(MGraph *G,int k){ //以Vk为源点对用邻接矩阵表示的图G进展广度优先搜索 int i,j,f=0,r=0;int cq[Ma*Verte*Num]; //定义队列for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)cq[i]=-1; //队列初始化printf("%c",G->ve*s[k]); //访问源点Vkvisited[k]=TRUE;cq[r]=k; //Vk已访问,将其入队。

数据结构-实验四图的的操作及应用

数据结构-实验四图的的操作及应用

实验四 图的的操作及应用实验课程名: 图的的操作及应用专业班级: 11计科(1) 学 号: 姓 名:实验时间: 2012. 12.11 实验地点: 指导教师:一、实验目的1、理解图的基本概念及术语;2、掌握图的两种存储结构(邻接矩阵和邻接表)的表示方法;3、熟练掌握图的两种遍历(深度优先搜索遍历和广度优先搜索遍历)的算法思想、步骤,并能列出在两种存储结构上按上述两种遍历算法得到的序列;4、理解最小生成树的概念,能按Prim算法构造最小生成树;领会并掌握拓扑排序、关键路径、最短路径的算法思想。

二、实验的内容和步骤1、构造图的邻接矩阵存储结构或邻接表存储结构。

代码:# include <iostream.h># include <malloc.h># include <conio.h># define INFINITY 1000# define MAX_VERTEX_NUM 20# define OK 1#define STARTS "********************************"typedef enum{DG,DN,UDG,UDN} GraphKind;typedef int EType;typedef int InfoType;typedef int VertexType;typedef struct ArcCell //define structure MGraph{ EType adj;InfoType *info;}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{ VertexType vexs[MAX_VERTEX_NUM];AdjMatrix arcs;int vexnum,arcnum;GraphKind kind;}MGraph;int CreatUDN(MGraph &G) //CreatUDN() sub-function{int IncInfo,i,j,k,v1,v2,w;cout<<endl<<"Please input the number of G.vexnum (eg,G.vexnum=4): ";cin>>G.vexnum; //input the number of vexcout<<"Please input the number of G.arcnum (eg,G.arcnum=4): ";cin>>G.arcnum; //input the number of arc: ";cout<<"Please input IncInfo (0 for none)cin>>IncInfo;for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;++j){ G.arcs[i][j].adj=INFINITY; //initial G.arcs[i][j].adj//initial G.arcs[i][j].infoG.arcs[i][j].info=NULL;}cout<<"Plese input arc(V1-->V2), For example: (V1=1,V2=3),(V1=2,V2=4)..."<<endl;for(k=0;k<G.arcnum;++k) //input arc(v1,v2){cout<<endl<<"Please input the "<<k+1<<"th arc's v1 (0<v1<G.vexnum) :";cin>>v1; //input v1cout<<"Please input the "<<k+1<<"th arc's v2 (0<v2<G.vexnum) :";cin>>v2; //input v2:";cout<<"Please input the "<<k+1<<"th arc's weightcin>>w; //input weighti=v1;j=v2;//if (v1,v2) illegal,againwhile(i<1||i>G.vexnum||j<1||j>G.vexnum){cout<<"Please input the "<<k+1<<"th arc's v1 (0<v1<G.vexnum) :";cin>>v1;cout<<"Please input the "<<k+1<<"th arc's v2 (0<v1<G.vexnum) :";cin>>v2;:";cout<<"Please input the "<<k+1<<"th arc's weightcin>>w;i=v1;j=v2;} //while endi--;j--;G.arcs[i][j].adj=G.arcs[j][i].adj=w; //weightcout<<"G.arcs["<<i+1<<"]["<<j+1<<"].adj="<<"G.arcs["<<j+1<<"]["<<i+1<<"].adj="<<w<<e ndl;if(IncInfo){ cout<<"Please input the "<<k+1<<"th arc's Info :";cin>>*G.arcs[i][j].info;}} //for endreturn (OK);} //CreatUDN() end打印邻接矩阵void Gprintf(MGraph G) //{cout<<"邻接矩阵数组为:\n";for(int i=0;i<G.vexnum;i++){for(int k=0;k<G.vexnum;k++)cout<<G.arcs[i][k].adj<<"\t";cout<<endl;}}/*邻接表*/typedef struct ArcNode //define structure ALGraph{ int adjvex;struct ArcNode *nextarc;InfoType *info;}ArcNode;typedef struct VNode{ VertexType data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{ AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;int CreateDG(ALGraph &G) //CreateDG() subfunction{ int IncInfo,i,j,k,v1,v2,w;cout<<endl<<"Please input the number of G.vexnum (eg,G.vexnum=4): "; cin>>G.vexnum; //input the number of vexcout<<"Please input the number of G.arcnum (eg,G.arcnum=4): ";cin>>G.arcnum; //input the numbe of arc: ";cout<<"Please input the number of IncInfo (0 for none)cin>>IncInfo; //if no information, input 0for(i=0;i<G.vexnum;++i){ G.vertices[i].data=i; //initial G.vertices[i].data//initial G.vertices[i].firstarcG.vertices[i].firstarc=NULL;}cout<<"Plese input arc(V1-->V2), For example: (V1=1,V2=3),(V1=2,V2=4)..."<<endl; for(k=0;k<G.arcnum;++k) //input arc(v1,v2){ cout<<endl<<"Please input the "<<k+1<<"th arc's v1 (0<v1<G.vexnum): ";cin>>v1;cout<<"Please input the "<<k+1<<"th arc's v2 (0<v2<G.vexnum0: ";cin>>v2;i=v1;j=v2;while(i<1||i>G.vexnum||j<1||j>G.vexnum) //if (v1,v2) illegal{ cout<<endl<<"Please input the "<<k+1<<"th arc's v1 (0<v1<G.vexnum): ";cin>>v1;cout<<"Please input the "<<k+1<<"th arc's v2 (0<v2<G.vexnum): ";cin>>v2;i=v1;j=v2;} //while endi--;j--;ArcNode *p;p=(ArcNode *)malloc(sizeof(ArcNode)); //allocate memoryif(!p){ cout<<"Overflow!";return (0);}p->adjvex=j; //assign p->adjvexp->nextarc=G.vertices[i].firstarc;p->info=NULL;G.vertices[i].firstarc=p;if(IncInfo){ cout<<"Please input the info :";//input informationcin>>*(p->info);}} //for endreturn (OK);} //CreateDG() endint main(){MGraph MG;ALGraph AG;int a=-1;while(a!=0){cout<<STARTS<<STARTS<<endl;cout<<"1)邻接矩阵(无向网)\t"<<"2)邻接表(有向图)\t"<<"3)退出"<<endl;cout<<"选择存储方式:";cin>>a;switch(a){case 1: {CreatUDN(MG);Gprintf(MG);break;}case 2: CreateDG(AG);break;case 3: a=0;break;选择错误\n"<<endl;default:cout<<"}}return 0;}运行结果:2.按照建立一个带权有向图的操作需要,编写在邻接矩阵或邻接表存储结构下,带权有向图基本操作的实现函数(如初始化图、在图中插入一个结点、在图中插入一条边、在图中寻找序号为v的结点的第一个邻接结点、在图中寻找序号为v1结点的邻接结点v2的下一个邻接结点、图的深度优先遍历、图的广度优先遍历等)。

实验四图的遍历与应用

实验四图的遍历与应用

实验四图的遍历与应用实验四图的遍历与应用一、实验目的1.掌握图的含义;2.掌握用邻接矩阵和邻接表的方法描述图的存储结构;3.理解并掌握深度优先遍历和广度优先遍历的存储结构。

二、实验要求1.认真阅读和掌握本实验的参考程序。

2.按照对图的操作需要,在创建好图后再通过遍历算法验证创建结果。

3.保存程序的运行结果,并结合程序进行分析。

三、实验内容以下参考程序是按邻接表的方法创建图,然后用深度优先遍历方法遍历图。

请认真理解程序,然后实现图的广度优先遍历。

参考程序:#define MaxVerNum 100 /* 最大顶点数为*/typedef enum {False,True} boolean;#include"stdio.h"#include"stdlib.h"boolean visited[MaxVerNum];typedef struct node /* 表结点*/{int adjvex;/* 邻接点域,一般是放顶点对应的序号或在表头向量中的下标*/char Info; /*与边(或弧)相关的信息*/struct node * next; /* 指向下一个邻接点的指针域*/} EdgeNode;typedef struct vnode /* 顶点结点*/{char vertex; /* 顶点域*/EdgeNode * firstedge; /* 边表头指针*/} VertexNode;typedef struct{VertexNode adjlist[MaxVerNum]; /* 邻接表*/int n,e; /* 顶点数和边数*/} ALGraph; /* ALGraph是以邻接表方式存储的图类型*///建立一个无向图的邻接表存储的算法如下:void CreateALGraph(ALGraph *G)/* 建立有向图的邻接表存储*/ {int i,j,k;int N,E;EdgeNode *p;printf("请输入顶点数和边数:");scanf("%d %d",&G->n,&G->e);printf("n=%d,e=%d\n\n",G->n,G->e);getchar();for(i=0;in;i++) /* 建立有n个顶点的顶点表*/{printf("请输入第%d个顶点字符信息(共%d个):",i+1,G->n); scanf("%c",&(G->adjlist[i].vertex)); /* 读入顶点信息*/ getchar();G->adjlist[i].firstedge=NULL; /* 顶点的边表头指针设为空*/}for(k=0;k<2*G->e;k++) /* 建立边表*/{printf("请输入边对应的顶点序号(共%d个):",2*G->e);scanf("%d %d",&i,&j);/* 读入边的顶点对应序号*/p=(EdgeNode *)malloc(sizeof(EdgeNode)); // 生成新边表结点pp->adjvex=j; /* 邻接点序号为j */p->next=G->adjlist[i].firstedge;/* 将结点p插入到顶点Vi的链表头部*/G->adjlist[i].firstedge=p;}printf("\n图已成功创建!对应的邻接表如下:\n");for(i=0;in;i++){p=G->adjlist[i].firstedge;printf("%c->",G->adjlist[i].vertex);while(p!=NULL){printf("[ %c ]",G->adjlist[p->adjvex].vertex);p=p->next;}printf("\n");}printf("\n");} /*CreateALGraph*/int FirstAdjVertex(ALGraph *g,int v)//找图g中与顶点v相邻的第一个顶点{if(g->adjlist[v].firstedge!=NULL) return (g->adjlist[v].firstedge)->adjvex;else return 0;}int NextAdjVertex(ALGraph *g ,int vi,int vj )//找图g中与vi相邻的,相对相邻顶点vj的下一个相邻顶点{EdgeNode *p;p=g->adjlist[vi].firstedge;while( p!=NULL && p->adjvex!=vj) p=p->next;if(p!=NULL && p->next!=NULL) return p->next->adjvex;else return 0;}void DFS(ALGraph *G,int v) /* 从第v个顶点出发深度优先遍历图G */{int w;printf("%c ",G->adjlist[v].vertex);visited[v]=True; /* 访问第v个顶点,并把访问标志置True */for(w=FirstAdjVertex(G,v);w;w=NextAdjVertex(G,v,w))if (!visited[w]) DFS(G,w); /* 对v尚未访问的邻接顶点w递归调用DFS */ }void DFStraverse(ALGraph *G)/*深度优先遍历以邻接表表示的图G,而以邻接矩阵表示时,算法完全相同*/{ int i,v;for(v=0;vn;v++)visited[v]=False;/*标志向量初始化*///for(i=0;in;i++)if(!visited[0]) DFS(G,0);}/*DFS*/void main(){ALGraph G;CreateALGraph(&G);printf("该无向图的深度优先搜索序列为:");DFStraverse(&G);printf("\nSuccess!\n");}//教材广度优先遍历算法的部分函数(以邻接矩阵为存储结构) Void BFStraverse (MGraph G){ /* 广度优先遍历图G */int i,v ;for(v=0;v<g.n;v++)< p="">visited[v]=False;/* 标志向量初始化*/for(i=0;i<g.n;i++)< p="">if(!visited[i])BFS (G,i);/* vi未访问过,从vi开始BFS搜索*/}void BFS(MGraph G,int v){ /* 以v为出发点,对图G进行BFS搜索*/int i,j;PSeqQueue Q;Q=Init_SeqQueue();Visite(v);/* 访问*/visited[v]=True;In_SeqQueue(Q,v);/* 原点入队列*/while(! Empty_SeqQueue(Q)){ Out_SeqQueue(Q,&i); /* vi出队列*/for(j=0;j<="" if(g.edges[i][j]="1" p="" 依次搜索vi的邻接点vj="" 若vj未访问*="">{ Visite(j);/* 访问vj */visited[j]=True;In_SeqQueue(Q,j);/* 访问过的vj入队列*/ }}}/*BFS*/</g.n;i++)<></g.n;v++)<>。

图的遍历实验报告

图的遍历实验报告

1.问题描述:不少涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序,演示在连通的无向图上访问全部结点的操作。

2.基本要求:以邻接表为存储结构,实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成树的边集。

3.测试数据:教科书图7.33。

暂时忽略里程,起点为北京。

4.实现提示:设图的结点不超过30个,每一个结点用一个编号表示(如果一个图有n个结点,则它们的编号分别为1,2,…,n)。

通过输入图的全部边输入一个图,每一个边为一个数对,可以对边的输入顺序作出某种限制,注意,生成树的边是有向边,端点顺序不能颠倒。

5.选作内容:(1) .借助于栈类型(自己定义和实现),用非递归算法实现深度优先遍历。

(2) .以邻接表为存储结构,建立深度优先生成树和广度优先生成树,再按凹入表或者树形打印生成树。

1.为实现上述功能,需要有一个图的抽象数据类型。

该抽象数据类型的定义为:ADT Graph{V 是具有相同特性的数据元素的集合,称为顶点集。

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为弧的类型。

图--0,1;网--权值int *Info; //与弧相关的信息的指针,可省略}ArcCell, AdjMatrix[max_n][max_n];typedef struct{VertexType vexs[max_n]; //顶点AdjMatrix arcs; //邻接矩阵int vexnum, arcnum; //顶点数,边数}MGraph;//队列的类型定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4.本程序包含三个模块1).主程序模块void main( ){创建树;深度优先搜索遍历;广度优先搜索遍历;}2).树模块——实现树的抽象数据类型3).遍历模块——实现树的深度优先遍历和广度优先遍历各模块之间的调用关系如下:主程序模块树模块遍历模块#include "stdafx.h"#include<iostream>using namespace std;#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};typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。

数据结构与算法实验报告 图的深度优先与广度优先遍历

数据结构与算法实验报告 图的深度优先与广度优先遍历
if(visited[w]==0){
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);

广度遍历的实验报告(3篇)

广度遍历的实验报告(3篇)

第1篇一、实验目的1. 理解广度遍历的基本概念和原理;2. 掌握广度遍历算法的编程实现;3. 熟悉图的邻接表表示方法;4. 分析广度遍历算法在图中的应用。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验原理广度遍历(Breadth-First Search,BFS)是一种基于图的遍历算法,它按照顶点的层次顺序访问图中的所有顶点。

具体来说,从起始顶点开始,首先访问起始顶点,然后访问起始顶点的所有邻接顶点,接着访问邻接顶点的邻接顶点,以此类推,直到遍历完所有顶点。

广度遍历算法通常采用队列数据结构来实现。

在遍历过程中,首先将起始顶点入队,然后从队列中依次取出顶点,访问其邻接顶点,并将邻接顶点入队。

这样,每个顶点都会按照其被访问的顺序入队,从而实现了广度遍历。

四、实验步骤1. 创建图:使用邻接表表示法创建实验所需的图。

2. 实现广度遍历算法:编写广度遍历算法的代码,实现图的遍历功能。

3. 运行实验:运行实验程序,观察广度遍历算法的执行过程和结果。

五、实验代码```cppinclude <iostream>include <vector>include <queue>using namespace std;// 定义图的结构体struct Graph {int numVertices; // 顶点数量vector<int> adjList; // 邻接表};// 初始化图void initGraph(Graph &g, int numVertices) {g.numVertices = numVertices;g.adjList.resize(numVertices);}// 添加边void addEdge(Graph &g, int src, int dest) {g.adjList[src].push_back(dest);}// 广度遍历void bfs(Graph &g, int startVertex) {queue<int> queue;vector<bool> visited(g.numVertices, false); // 访问标记数组 // 将起始顶点入队queue.push(startVertex);visited[startVertex] = true;while (!queue.empty()) {int vertex = queue.front();cout << "访问顶点: " << vertex << endl; queue.pop();// 遍历邻接顶点for (int neighbor : g.adjList[vertex]) { if (!visited[neighbor]) {queue.push(neighbor);visited[neighbor] = true;}}}}int main() {// 创建图Graph g;initGraph(g, 6);addEdge(g, 0, 1);addEdge(g, 0, 2);addEdge(g, 1, 3);addEdge(g, 1, 4);addEdge(g, 2, 5);addEdge(g, 3, 5);addEdge(g, 4, 5);// 广度遍历cout << "广度遍历结果:" << endl;bfs(g, 0);return 0;}```六、实验结果与分析运行实验程序,可以得到以下输出:```访问顶点: 0访问顶点: 1访问顶点: 2访问顶点: 3访问顶点: 4访问顶点: 5```从输出结果可以看出,广度遍历算法按照顶点的层次顺序访问了图中的所有顶点,符合预期。

实验四 图的深度优先与广度优先遍历

实验四  图的深度优先与广度优先遍历
实验四 图的深度优先与广度优先遍历
实验时间:2011年5月12日,12:50 -15:50(地点:7-215) 实验目的:理解图的逻辑特点;掌握理解图的两种主要存储结构(邻接 矩阵和邻接表),掌握图的构造、深度优先遍历、广度优先遍历算法。 具体实验题目:(任课教师根据实验大纲自己指定) 每位同学按下述要求实现相应算法: 根据从键盘输入的数据创建 图(图的存储结构可采用邻接矩阵或邻接表),并对图进行深度优先搜 索和广度优先搜索 1)问题描述:在主程序中提供下列菜单: 1…图的建立 2…深度优先遍历图 3…广度优先遍历图 0…结束 2)实验要求:图的存储可采用邻接表或邻接矩阵;定义下列过 程: CreateGraph(): 按从键盘的数据建立图 DFSGrahp():深度优先遍历图 BFSGrahp():广度优先遍历图
void MatToList(MGraph g,ALGraph *&G) G { int i,j; int n=g.n; //n为顶点数 ArcNode *p; //弧节点结构的类型 G=(ALGraph *)malloc(sizeof(ALGraph));
//将邻接矩阵g转换为邻接表
for(i=0;i<n;i++) //给大的邻接表中所有头结点的指针域副初值 G->adjlist[i].firstarc=NULL; for(i=0;i<n;i++) //检查邻接矩阵的每个元素 for(j=0;j<n;j++) if(g.edges[i][j]!=0) { p=(ArcNode *)malloc(sizeof(ArcNode)); //新申请一个节点空 间,就是后面的一段段小的节点 p->adjvex=j; //这是小节点的放值的域,只要他的列值,链式 表只要说明节点之间有关系就行,指终点位置 p->info=g.edges[i][j]; //存放边的权值

实验四图的应用深度优先广度优先搜索遍历

实验四图的应用深度优先广度优先搜索遍历

数据结构实验报告实验四图的应用一、实验题目:图的应用——深度优先/广度优先搜索遍历二、实验内容:很多涉及图上操作的算法都是以图的遍历操作为基础的。

试编写一个算法,实现图的深度优先和广度优先搜索遍历操作。

要求:以邻接矩阵或邻接表为存储结构,以用户指定的顶点为起始点,实现连通无向图的深度优先及广度优先搜索遍历,并输出遍历的结点序列。

(注:学号为奇数的同学使用邻接矩阵存储结构实现,学号为偶数的同学使用邻接矩阵实现)提示:首先,根据用户输入的顶点总数和边数,构造无向图,然后以用户输入的顶点为起始点,进行深度优先、广度优先搜索遍历,并输出遍历的结果。

三、程序源代码:#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)表示一条边,它是有方向的。

图的深度和广度优先遍历

图的深度和广度优先遍历

数据结构课程实验报告课程名称数据结构班级计算123 实验日期2014年6月1日--3日姓名学号实验成绩实验名称实验四图的深度和广度优先遍历实验目的及要求【实验目的】熟练掌握图的邻接表存储结构及其图的建立方法和深度和广度优先遍历的方法。

【实验要求】1.图的存储可采用邻接矩阵或邻接表2.GraphCreate(): 按从键盘的数据建立图3.GraphDFS():深度优先遍历图4.GraphBFS():广度优先遍历图5.编写完整程序完成下面的实验内容并上机运行6.整理并上交实验报告实验环境硬件平台:普通的PC机软件平台:Windows 7 操作系统编程环境:VisualC++ 6.0实验内容1.以邻接矩阵或邻接表为存储结构,以用户指定的顶点为起始点,实现图的深度优先及广度优先搜索遍历,并输出遍历的结点序列。

算法描述及实验步骤算法:1)定义图的邻接表存储结构2)实现图的邻接表存储,即建立图的存储结构3)实现图的深度优先遍历4)定义队列的顺序存储结构,并实现队列的基本操作如初始化队列、入队、出对、判断队列是否为空等。

利用队列实现图的广度优先遍历。

伪代码:1)定义邻接矩阵和队列的存取结构;2)创建图L:1.置空图L->num=0;2.输入顶点数目num;3.i++,输入结点L->vexs[i]直到L->num;3)输出图L的各顶点;4)深度优先遍历图g中能访问的各个顶点1.输入起点的下标qidian;2.标志数组初始化mark[v]=0;3.for(v=qidian;v<g.num+qidian;v++) //{v1=v%g.num;if(mark[v1]==0)DFS(g,v1,mark); //从第v1个点出发深度优先遍历图g中能访问的各个顶点(算法描述里的流程图很详细)}5)广度优先周游图g中能访问的各个顶点。

1.构造空队列;2.入队a[0];3.a[0]出队,a[0]的邻接点入队,遍历a[0];4.队首出队,重复3直到队列为空;5.判断是否全遍历完了;6.输出广度优先遍历序列流程图:开始访问V 0,置标志求V 0邻接点有邻接点w求下一邻接点w V 0W 访问过结束NYN YDFS开始标志数组初始化V i =1Vi 访问过DFSV i =V i +1V i ==Vexnums结束NNYY调试过程及实验结果总结本次试验采用的是邻接表的方式实现图的深度优先遍历和广度优先遍历。

图的遍历实验报告.doc

图的遍历实验报告.doc

图的遍历实验报告实验4:图的遍历主题:图及其应用——图的遍历类;姓名:学生编号:完成日期:一、需求分析1。

问题描述:许多涉及图操作的算法都是基于图遍历操作的。

试着写一个程序来演示访问连通无向图上所有节点的操作。

2.基本要求:邻接表作为存储结构,实现了连通无向图的深度优先和广度优先遍历。

从用户指定的节点开始,分别输出每次遍历下的节点访问顺序和相应生成树的边集。

3.测试数据:教科书中的图7.33。

暂时忽略里程,从北京开始。

4.实施提示: 假设一个图不超过30个节点,每个节点用一个数字表示(如果一个图有n个节点,它们的数字是1,2,分别为n)。

通过将一个图的所有边输入到一个图中,每个边是一对,边的输入顺序可以被限制。

请注意,生成树的边是有向边,端点的顺序不能颠倒。

5.选定内容:(1)。

借助堆栈类型(自行定义和实现),使用非递归算法实现深度优先遍历。

(2)以邻接表为存储结构,建立深度优先生成树和广度优先生成树,然后根据凹表或树打印生成树。

为了实现上述功能,需要图形的抽象数据类型。

抽象数据类型定义为:ADT图{数据对象v:v是一组具有相同特征的数据元素,称为顶点集。

数据关系r:R={VR} VR={ | v,wv和P(v,w),表示从v到w的弧,谓词P(v,w)定义弧的含义或信息}} ADT图2。

该抽象数据类型中的一些常量如下:#定义true1 #定义false 0 #定义ok 1 #定义max _ n 20//最大顶点数typedef char顶点类型[20];typedef枚举{DG,DN,AG,AN}图形种类;枚举BOOL {假,真};3.树的结构类型如下:Typedef结构{//圆弧节点和矩阵的int类型调整;//VRType是弧的类型。

图的遍历主题——图;图及其应用——图的遍历类;姓名:学生编号:完成日期:一、需求分析1。

问题描述:许多涉及图操作的算法都是基于图遍历操作的。

试着写一个程序来演示访问连通无向图上所有节点的操作。

【数据结构与数据库-实验报告】图的遍历(深度和广度)

【数据结构与数据库-实验报告】图的遍历(深度和广度)

1
3
5
7
六 心得体会
1、通过实验更加了解队列及图的知识 2、本程序界面不够人性化,且功能不够完善,需改进。
七 实验源程序(附件)
#include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h>
9 / 16
版权归原作者 Amber 所有
//出队 //清空队 //结点定义
11 / 16
版权归原作者 Amber 所有
int kind; }ALGraph; int LocateVex(ALGraph G,char v){
int i,j=-1; for(i=0;i<G.vexnum;i++)
if(G.vertices[i].data==v) j=i;
p=(ArcNode*)malloc(sizeof(ArcNode)); p->adjvex=i; p->nextarc=G.vertices[j].firstarc; G.vertices[j].firstarc=p; } } } 3、打印图 void PrintGraph(ALGraph G){ int i; ArcNode *p; for(i=0;i<G.vexnum;i++){ printf("%d\t",G.vertices[i].data);
版权归原作者 Amber 所有
数据结构与数据库 实验报告
题目 院系 姓名 学号 指导老师 提交时间
图的遍历(深/广度) 化学物理系 ******* 月 5 日 星期三
1 / 16
一 实验内容

数据结构实验四 图的遍历与应用

数据结构实验四 图的遍历与应用

5 2 16 3 47 0 实验四 图的遍历与应用程序说明:该程序是用邻接矩阵的方法创建图,然后用广度优先遍历方法遍历。

程序中运用队列来保存遍历的结点,将访问过的邻接顶点依次入队列Q ,先进先出,找各个顶点的邻接顶点依次入队列。

遍历的过程中需要一个访问标志数组,将访问的顶点置为True ,避免重复访问。

该程序测试时用的图为:执行结果:源代码:#include<iostream>#include<stdlib.h>using namespace std ;#define MaxVerNum 100typedef enum {False,True} boolean ;boolean visited[MaxVerNum] ;typedef struct{int data[MaxVerNum] ;int frout ,rear ;}SeqQueue ,*PSeqQueue;PSeqQueue Init_SeqQueue(){PSeqQueue Q;Q = (PSeqQueue)malloc (sizeof(SeqQueue)) ;if(Q){Q->frout = 0 ;Q->rear = 0 ;}return Q ;}int Empty_SeqQueue(PSeqQueue Q){if(Q && Q->frout == Q->rear)return 1 ;elsereturn 0 ;}int In_SeqQueue(PSeqQueue Q , int x){if((Q->rear+1)%MaxVerNum == Q->frout){cout<<"队满!" ;return -1 ;}else{Q->rear = (Q->rear+1)%MaxVerNum ;Q->data[Q->rear] = x ;}}int Out_SeqQueue(PSeqQueue Q , int *x){if(Empty_SeqQueue(Q)){cout<<"队空!" ;return -1 ;}else{Q->frout = (Q->frout+1)%MaxVerNum ;*x = Q->data[Q->frout] ;return 1 ;}}typedef struct{int vexs[MaxVerNum] ;int edges[MaxV erNum][MaxVerNum] ;int n , e ;void CreatGraph(MGraph *G){int i , j , k , m , n ;cout<<"请输入顶点数和边数:" ;cin>>G->n ;cin>>G->e ;for(i = 0 ; i < G->n ; i ++){cout<<"请输入第"<<i+1<<"个顶点信息:" ;cin>>G->vexs[i] ;}for(i = 0 ; i < G->n ; i ++)for(j = 0 ; j < G->n ; j ++)G->edges[i][j] = 0 ;for(k = 0 ; k < G->e ; k ++){cout<<"请输入第"<<k+1<<"条边对应的顶点:" ;cin>>i ;cin>>j ;for(m = 0 ; m < G->e ; m ++)if(G->vexs[m] == i)break ;for(n = 0 ; n < G->e ; n ++)if(G->vexs[n] == j)break ;G->edges[m][n] = G->edges[n][m] = 1 ;}cout<<endl<<"图已创建成功!对应的邻接矩阵为:"<<endl ;for(i = 0 ; i < G->n ; i ++){for(j = 0 ; j < G->n ; j ++)cout<<G->edges[i][j]<<" " ;cout<<endl ;}cout<<endl ;}void BFS(MGraph *G ,int v){PSeqQueue Q ;Q = Init_SeqQueue() ;cout<<G->vexs[v] ;visited[v] = True ;In_SeqQueue(Q,v) ;while(!Empty_SeqQueue(Q)){Out_SeqQueue(Q,&i) ;for(j = 0 ; j < G->n ; j ++)if(G->edges[i][j] == 1 && !visited[j]){cout<<G->vexs[j] ;visited[j] = True ;In_SeqQueue(Q,j) ;}}}void BFStraverse(MGraph *G){int i , v ;for(v = 0 ; v < G->n ; v ++)visited[v] = False ;for(i = 0 ; i < G->n ; i ++)if(!visited[i])BFS(G , i) ;}void main(){MGraph G ;CreatGraph(&G) ;cout<<"该无向图的广度优先搜索序列为:"<<endl ;BFStraverse(&G) ;cout<<endl<<"Success!"<<endl ;}。

实习四 图及其应用-图遍历的演示

实习四 图及其应用-图遍历的演示

实习四图及其应用题目: 图遍历的演示实习时间:2012/11/20一、需求分析1.问题描述:很多涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序,演示连通的无向图上行遍全部结点的操作。

2.基本要求:以邻接多重表为存储结构,实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成树的边集。

3.测试数据:二、设计1. 设计思想(1)存储结构邻接多重表为存储结构(2)主要算法基本思想所有代码思想均由老师授课所得:深度优先搜索(Depth-first Search,DFS)①首先访问起始顶点v,再访问图中与v相邻接的且未被访问过的任一顶点w1;②再从w1出发,访问与w1相邻接的且未被访问过的任一顶点w2;③从w2出发,重复与步骤②类似的访问,直至遇到一个所有邻接点均被访问过的顶点为止;④沿刚才访问的次序,反向回到一个尚有邻接点未被访问过的顶点,再从该顶点出发,重复与步骤③相类似的访问,直到所有的被访问过的顶点的邻接顶点均被访问过为止。

广度优先搜索(Breadth-first Search,BFS)①访问起始顶点v后,依次访问与v相邻接的所有顶点w1, w2, …, wt;②再按w1, w2, …, wt的顺序,访问其中每一个顶点的所有未被访问过的邻接顶点;对w1为:w11, w12, …,w1m;…;对wt为:wt1, wt2, …, wtn等;③再按w11, w12, …, w1m, w21, …, wt1, wt2, …, wtn的顺序,去访问它们各自的未被访问过的邻接顶点。

依次类推,直到图中所有被访问过的顶点的邻接顶点都被访问过为止。

2. 设计表示(1)函数调用关系图main→Initilized→CreateGraph→SetMark→DFS→BFS (2)函数接口规格说明void Initilized(Graph *graph) // graph指向的图的初始化void CreateGraph(Graph *graph) //graph指向的图的创建图void SetMark(Graph *graph) //设置graph指向的图的顶点访问标记void DFS(Graph *graph,int v) //深度遍历graph指向的图的点amlist [v] void BFS(Graph *graph,int u) //广度遍历graph指向的图的点amlist [v] 3. 实现注释(即各项功能的实现程度)程序缺乏健壮性。

实验四 图的遍历算法

实验四   图的遍历算法

实验四图的遍历算法4.1.实验的问题与要求1.如何对给定图的每个顶点各做一次且仅做一次访问?有哪些方法可以实现图的遍历?2.如何用这些算法解决实际问题?3.熟练掌握图的基本存储方法4.熟练掌握图的两种搜索路径的遍历方法5.掌握有关图的操作算法并用高级语言实现4.2.实验的基本思想和基本原理和树的遍历类似,图的遍历也是从某个顶点出发,沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。

它是许多图的算法的基础。

遍历常用两种方法:深度优先搜索遍历;广度优先搜索遍历4.2.1 深度优先搜索(Depth-First Traversal)深度优先搜索是一种递归的过程,正如算法名称那样,深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。

在深度优先搜索中,对于最新发现的顶点,如果它还有以此为起点而未探测到的边,就沿此边继续下去。

当结点v的所有边都己被探寻过,搜索将回溯到发现结点v有那条边的始结点。

这一过程一直进行到已发现从源结点可达的所有结点为止。

如果还存在未被发现的结点,则选择其中一个作为源结点并重复以上过程,整个进程反复进行直到所有结点都被发现为止。

1.图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。

在G中任选一顶点v 为初始出发点(源点),则深度优先遍历可定义如下:首先访问出发点v,并将其标记为已访问过;然后依次从v出发搜索v的每个邻接点w。

若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。

若此时图中仍有未访问的顶点,则另选一个尚未访问的顶点作为新的源点重复上述过程,直至图中所有顶点均已被访问为止。

图的深度优先遍历类似于树的前序遍历。

采用的搜索方法的特点是尽可能先对纵深方向进行搜索。

这种搜索方法称为深度优先搜索(Depth-First Search)。

相应地,用此方法遍历图就很自然地称之为图的深度优先遍历。

深度优先遍历算法和广度优先遍历算法实验小结

深度优先遍历算法和广度优先遍历算法实验小结

深度优先遍历算法和广度优先遍历算法实验小结一、引言在计算机科学领域,图的遍历是一种基本的算法操作。

深度优先遍历算法(Depth First Search,DFS)和广度优先遍历算法(Breadth First Search,BFS)是两种常用的图遍历算法。

它们在解决图的连通性和可达性等问题上具有重要的应用价值。

本文将从理论基础、算法原理、实验设计和实验结果等方面对深度优先遍历算法和广度优先遍历算法进行实验小结。

二、深度优先遍历算法深度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历,沿着一条路径一直向前直到不能再继续前进为止,然后退回到上一个节点,尝试下一个节点,直到遍历完整个图。

深度优先遍历算法通常使用栈来实现。

以下是深度优先遍历算法的伪代码:1. 创建一个栈并将起始节点压入栈中2. 将起始节点标记为已访问3. 当栈不为空时,执行以下步骤:a. 弹出栈顶节点,并访问该节点b. 将该节点尚未访问的邻居节点压入栈中,并标记为已访问4. 重复步骤3,直到栈为空三、广度优先遍历算法广度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历,先访问起始节点的所有相邻节点,然后再依次访问这些相邻节点的相邻节点,依次类推,直到遍历完整个图。

广度优先遍历算法通常使用队列来实现。

以下是广度优先遍历算法的伪代码:1. 创建一个队列并将起始节点入队2. 将起始节点标记为已访问3. 当队列不为空时,执行以下步骤:a. 出队一个节点,并访问该节点b. 将该节点尚未访问的邻居节点入队,并标记为已访问4. 重复步骤3,直到队列为空四、实验设计本次实验旨在通过编程实现深度优先遍历算法和广度优先遍历算法,并通过对比它们在不同图结构下的遍历效果,验证其算法的正确性和有效性。

具体实验设计如下:1. 实验工具:使用Python编程语言实现深度优先遍历算法和广度优先遍历算法2. 实验数据:设计多组图结构数据,包括树、稠密图、稀疏图等3. 实验环境:在相同的硬件环境下运行实验程序,确保实验结果的可比性4. 实验步骤:编写程序实现深度优先遍历算法和广度优先遍历算法,进行多次实验并记录实验结果5. 实验指标:记录每种算法的遍历路径、遍历时间和空间复杂度等指标,进行对比分析五、实验结果在不同图结构下,经过多次实验,分别记录了深度优先遍历算法和广度优先遍历算法的实验结果。

图的遍历深度优先遍历和广度优先遍历

图的遍历深度优先遍历和广度优先遍历
while (p!=NULL)
{ if (!visited[p->endNo] ) //若p未访问,则从p出发深度优先遍历
nNodes = nNodes+DFS2(nodes, n, p->endNo, visited, resu,top);
p = p->next; //令p指向v0的下个出点 }
return nNodes; } 与邻接矩阵的情况类似,也可以对该程序“包装”,以隐蔽visited和top。
其分配空间
long nNodes, i;
TGraphEdgeAL<TEdgeElem> *p; nNodes=1;
第十七页,课件共44页
resu[top++]=v0; //将访问到的结点依次存于resu[] visited[v0]=1; //置v0为“已访问”标志 p = nodes[v0].firstOutEdge; //求出v0的第一个出点p
nNodes = nNodes+DFS1(g, n, i, visited,resu);
//从i起深度优先遍历图 }
return nNodes; }
第十四页,课件共44页
上面函数中的参数visited和top实质上是中间变量,只是为了
避免在递归调用时重新初始化而放在参数表中,造成使用的
不方便,为此,做个包装A程序如:果 不 想 让 visited 或
下面只考虑从一点出发遍历,因此有可能会出 现遍历不到的点。即那些初始点无路径可达的 点,是遍历不到的。
第七页,课件共44页
20.2 深度优先遍历
(一) 遍历规则
从图中某结点v0出发,深度优先遍历(DFS: Depth First Search)图的规则为:

图的遍历(实验报告附C++源码)

图的遍历(实验报告附C++源码)

图的遍历一、问题背景若用有向网表示网页的链接网络,其中顶点表示某个网页,有向弧表示网页之间的链接关系。

试设计一个网络蜘蛛系统,分别以广度优先和深度优先的策略抓取网页。

二、需求分析1)首先输入顶点的数量,然后是各顶点对应的字母,再输入各条弧(权值都置为1);2)输出从首个顶点开始的广度优先遍历序列和深度先遍历序列;3)为了达到任意图的遍历(结点名称不一定是数字,可以是任意可见字符),可以自定义一个数组类型,保存该结点的名称和记录是否被访问;4)图使用相邻矩阵来实现;5)测试数据:输入输入顶点数和弧数:8 9输入8个顶点.输入顶点0:a输入顶点1:b输入顶点2:c输入顶点3:d输入顶点4:e输入顶点5:f输入顶点6:g输入顶点7:h输入9条弧.输入弧0:a b 1输入弧1:b d 1输入弧2:b e 1输入弧3:d h 1输入弧4:e h 1输入弧5:a c 1输入弧6:c f 1输入弧7:c g 1输入弧8:f g 1输出广度优先遍历: a b d h e c f g深度优先遍历: a b c d e f g h三、概要设计抽象数据类型为了遍历任意图,定义了如下数据类型,用于存储该结点的名称和记录是否被访问过。

class Node//基本抽象数据类型{public:char ch; //记录名称,如果将这里改成数组,结点名称可以是多个字符int flag;//记录结点是否被访问};class Graph //图类,此类中,封装了图的一些成员和一些必须的成员函数{private:int getSub(char); //获取某名称的下标Node* arrNode; //记录名称和是否访问的数组int numVertex,numEdge;//记录图的顶点数和边数int **matrix; //用一个二维数组记录两点间是否相连,1相连,0断开public:void setCh(char,int); //将数组的arrNode的每一个单元设置一个结点名称Graph(int);~Graph();int getNumVertex();//获得图的顶点数char first(char ch);//获得相邻结点char next(char ch1,char ch2);//获得隔着ch2,但与ch2相邻的结点void setEdge(char,char,int w=1);//设置两顶点的边和权重(权重默认为1)int getMark(char);//获取是否被访问的记录,已访问返回1,未访问返回0void setMark(char);//把已访问的结点,设置标记};算法的基本思想用一个自定义类型的数组,记录每个结点的信息(包括名称、是否被访问),且此数组作为图的成员变量之一;用一个类,对数组进行相应的操作,以便获得所需的信息。

图的广度优先遍历实验报告

图的广度优先遍历实验报告
2017学年学期课程名称数据结构及应用算法教程实验内容图的广度优先遍历实验时间2017学院系计算机工程学院学生姓名实验名称图的广度优先遍历实验目的和要求先访问完当前顶点的所有邻接点
实验报告
(2016/2017学年第2学期)
课程名称
数据结构及应用算法教程
实验时间
2017年5月5日
指导教师
专 业
学院(系)
int i,j;
for(i=0;i<VERTEXNUM;i++){
for(j=0;j<VERTEXNUM;j++){
edge[i][j] = 0;
} }
int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
for(i=0;i<VERTEXNUM;i++){
计算机工程学院
学生姓名
学号
实 验 报 告
实验名称
图的广度优先遍历
一、实验目的和要求
先访问完当前顶点的所有邻接点。
先访问顶点的邻接点先于后访问顶点的邻接点被访问。
二、实验内容
#include <stdio.h>
#include <malloc.h>
#define VERTEXNUM 5
typedef struct qElement{
if(front == NULL){
rear = front;
}else{
front->pre = NULL;
}
free(p);
p = NULL;
return res;
} }
void putRelatedInQueue(int (*edge)[VERTEXNUM], int vertex){
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验四图的遍历与应用一、实验目的1.掌握图的含义;2.掌握用邻接矩阵和邻接表的方法描述图的存储结构;3.理解并掌握深度优先遍历和广度优先遍历的存储结构。

二、实验要求1.认真阅读和掌握本实验的参考程序。

2.按照对图的操作需要,在创建好图后再通过遍历算法验证创建结果。

3.保存程序的运行结果,并结合程序进行分析。

三、实验内容以下参考程序是按邻接表的方法创建图,然后用深度优先遍历方法遍历图。

请认真理解程序,然后实现图的广度优先遍历。

广度优先遍历:具体实验的详细代码:#define MaxVerNum 100 /* 最大顶点数为*/#define MAXSIZE 100typedef enum {False,True} boolean;#include "stdio.h"#include "stdlib.h"typedef int DataType;boolean visited[MaxVerNum];typedef struct /*定義一個隊列*/{DataType data[MAXSIZE];int front,rear;}SeqQueue,*PSeqQueue;PSeqQueue Init_SeqQueue() /*隊列初始化*/{PSeqQueue Q;Q=(PSeqQueue)malloc(sizeof(SeqQueue));if(Q){Q->front=0;Q->rear=0;}return Q;}int In_SeqQueue(PSeqQueue Q,DataType x) /*入隊操作*/{if((Q->rear+1)%MAXSIZE==Q->front){printf("隊滿");return -1;}else{Q->rear=(Q->rear+1)%MAXSIZE;Q->data[Q->rear]=x;return 1;}}int Empty_SeqQueue(PSeqQueue Q) /*判斷隊空*/{if(Q&&Q->front==Q->rear)return (1);elsereturn (0);}int Out_SeqQueue(PSeqQueue Q,DataType *x) /*出對操作*/{if(Empty_SeqQueue(Q)){printf("隊空");return -1;}else{Q->front=(Q->front+1)%MAXSIZE;*x=Q->data[Q->front];return 1;}}typedef struct node /* 表结点*/{int adjvex;/* 邻接点域,一般是放顶点对应的序号或在表头向量中的下标*/ char Info; /*与边(或弧)相关的信息*/struct node * next; /* 指向下一个邻接点的指针域*/} EdgeNode;typedef struct vnode /* 顶点结点*/{char vertex; /* 顶点域*/EdgeNode * firstedge; /* 边表头指针*/} VertexNode;typedef struct{VertexNode adjlist[MaxVerNum]; /* 邻接表*/int n,e; /* 顶点数和边数*/} ALGraph; /* ALGraph是以邻接表方式存储的图类型*/void Visit(DataType w){printf ("%d",w);}//建立一个无向图的邻接表存储的算法如下:void CreateALGraph(ALGraph *G)/* 建立有向图的邻接表存储*/{int i,j,k;/*int N,E;*/EdgeNode *p;printf("请输入顶点数和边数:");scanf("%d %d",&G->n,&G->e);printf("n=%d,e=%d\n\n",G->n,G->e);getchar();for(i=0;i<G->n;i++) /* 建立有n个顶点的顶点表*/{printf("请输入第%d个顶点字符信息(共%d个):",i+1,G->n);scanf("%c",&(G->adjlist[i].vertex)); /* 读入顶点信息*/getchar();G->adjlist[i].firstedge=NULL; /* 顶点的边表头指针设为空*/ }for(k=0;k<2*G->e;k++) /* 建立边表*/{printf("请输入边<Vi,Vj>对应的顶点序号(共%d个):",2*G->e);scanf("%d %d",&i,&j);/* 读入边<Vi,Vj>的顶点对应序号*/p=(EdgeNode *)malloc(sizeof(EdgeNode)); // 生成新边表结点pp->adjvex=j; /* 邻接点序号为j */p->next=G->adjlist[i].firstedge;/* 将结点p插入到顶点Vi的链表头部*/G->adjlist[i].firstedge=p;}printf("\n图已成功创建!对应的邻接表如下:\n");for(i=0;i<G->n;i++){p=G->adjlist[i].firstedge;printf("%c->",G->adjlist[i].vertex);while(p!=NULL){printf("[ %c ]",G->adjlist[p->adjvex].vertex);p=p->next;}printf("\n");}printf("\n");} /*CreateALGraph*/int FirstAdjVertex(ALGraph *g,int v)//找图g中与顶点v相邻的第一个顶点{if(g->adjlist[v].firstedge!=NULL) return (g->adjlist[v].firstedge)->adjvex;else return 0;}int NextAdjVertex(ALGraph *g ,int vi,int vj )//找图g中与vi相邻的,相对相邻顶点vj的下一个相邻顶点{EdgeNode *p;p=g->adjlist[vi].firstedge;while( p!=NULL && p->adjvex!=vj) p=p->next;if(p!=NULL && p->next!=NULL) return p->next->adjvex;else return 0;}void BFS(ALGraph *G,int v){/*從v出發按廣度優先遍歷圖G;使用輔助隊列Q和訪問標誌數組visited*/ EdgeNode *p;int u,w;PSeqQueue Q; /*定義一個隊列*/Q=Init_SeqQueue(); /*置空的隊列Q*/Visit(v); /*訪問v,注意Visit函數和visited數組的區別*/visited[v]=True; /*把訪問標誌置True*/In_SeqQueue(Q,v); /*v入隊列*/while(!Empty_SeqQueue(Q)){Out_SeqQueue(Q,&u); /*出隊列*/for(p=G->adjlist[u].firstedge;p;p=p->next){w=p->adjvex;if(!visited[w]){Visit(w);visited[w]=True;In_SeqQueue(Q,w); /*u的尚未訪問的鄰接頂點w入隊列Q*/}}}} /*BFS*/void BFStraverse(ALGraph G){int v;for(v=0;v<G.n;v++)visited[v]=False;for(v=0;v<G.n;v++)if(!visited[v])BFS(&G,v);}void main(){int v;ALGraph G;CreateALGraph(&G);printf("该无向图的廣度优先搜索序列为:");BFStraverse(G);printf("\nSuccess!\n");}广度优先遍历实验结果截图:。

相关文档
最新文档