C语言_数据结构_实验7_图的创建与遍历 2

合集下载

数据结构实验---图的储存与遍历

数据结构课程实验报告一、实验目的掌握图这种复杂的非线性结构的邻接矩阵和邻接表的存储表示, 以及在此两种常用存储方式下深度优先遍历(DFS)和广度优先遍历(BFS)操作的实现。

二、实验内容与实验步骤题目1: 对以邻接矩阵为存储结构的图进行DFS和BFS遍历问题描述: 以邻接矩阵为图的存储结构, 实现图的DFS和BFS遍历。

基本要求：建立一个图的邻接矩阵表示, 输出顶点的一种DFS和BFS序列。

测试数据: 如图所示题目2: 对以邻接表为存储结构的图进行DFS和BFS遍历问题描述: 以邻接表为图的存储结构, 实现图的DFS和BFS遍历。

基本要求：建立一个图的邻接表存贮, 输出顶点的一种DFS和BFS序列。

测试数据: 如图所示三、附录:在此贴上调试好的程序。

#include<stdio.h>#include<malloc.h>#include<string.h>#define M 100typedef struct node{char vex[M][2];int edge[M ][ M ];int n,e;}Graph;int visited[M];Graph *Create_Graph(){ Graph *GA;int i,j,k,w;GA=(Graph*)malloc(sizeof(Graph));printf ("请输入矩阵的顶点数和边数(用逗号隔开): \n");scanf("%d,%d",&GA->n,&GA->e);printf ("请输入矩阵顶点信息: \n");for(i = 0;i<GA->n;i++)scanf("%s",&(GA->vex[i][0]),&(GA->vex[i][1]));for (i = 0;i<GA->n;i++)for (j = 0;j<GA->n;j++)GA->edge[i][j] = 0;for (k = 0;k<GA->e;k++){ printf ("请输入第%d条边的顶点位置(i,j)和权值(用逗号隔开): ",k+1);scanf ("%d,%d,%d",&i,&j,&w);GA->edge[i][j] = w;}return(GA);}void dfs(Graph *GA, int v){ int i;printf("%c%c\n",GA->vex[v][0],GA->vex[v][1]);visited[v]=1;for(i=0; i<GA->n; i++)if (GA->edge[v][i]==1 && visited[i]==0) dfs(GA, i);}void traver(Graph *GA){ int i;for(i=0; i<GA->n; i++)visited[i]=0;for(i=0; i<GA->n;i++)if(visited[i]==0)dfs(GA, i);}void bfs( Graph *GA, int v){ int j,k,front=-1,rear=-1;int Q[M];printf("%c%c\n",GA->vex[v][0],GA->vex[v][1]); visited[v]=1;rear=rear+1;Q[rear]=v;while (front!=rear){ front=front+1;k=Q[front];for (j=0; j<GA->n; j++)if (GA->edge[k][j]==1 && visited[j]==0){ printf("%c%c\n",GA->vex[j][0],GA->vex[j][1]);visited[j]=1;rear=rear+1;Q[rear]=j;}}}void traver1(Graph *GA){ int i;for (i=0; i<GA->n;i++)visited[i]=0;for (i=0; i<GA->n; i++)if (visited[i]==0)bfs(GA, i);}typedef struct NODE{ int adjvex;struct NODE *next;}ENode;typedef struct NODE1{ char vex[2];ENode *first;} VexNode;typedef struct FS1{VexNode GL[M];int bian,top;}FS;FS *CreateGL( ){ FS *kk=(FS *)malloc(sizeof(FS));int i,j,k;ENode *s;printf("请输入顶点数和边数(用逗号隔开): \n");scanf("%d,%d",&kk->top, &kk->bian);printf("请输入顶点信息: \n");for (i=0; i<kk->top; i++){ scanf("%s",kk->GL[i].vex);kk->GL[i].first=NULL; }printf("请输入边的信息(i,j): \n");for (k=0;k<kk->bian;k++){ scanf("\n%d,%d",&i,&j);s =(ENode*)malloc(sizeof(ENode));s->adjvex=j;s->next=kk->GL[i].first;kk->GL[i].first =s;}return kk;}void DFS(FS *kk, int v){ ENode *w; int i;printf("%s\n",kk->GL[v].vex); visited[v]=1;w=kk->GL[v].first ;while (w!=NULL){ i=w->adjvex;if (visited[i]==0)DFS(kk,i);w=w->next;}}void TRAVER(FS *kk){ int i;for(i=0; i<kk->top;i++)visited[i]=0;for(i=0; i<kk->top; i++)if(visited[i]==0)DFS(kk, i);}void BFS(FS *kk, int v){ int Q[M], front=-1,rear=-1;ENode *w;int i, k;printf("%s\n",kk->GL[v].vex);visited[v]=1;rear=rear+1; Q[rear]=v;while (front!=rear){ front=front+1;k=Q[front];w=kk->GL[k].first;while(w!=NULL){ i=w->adjvex;if( visited[i]==0){ visited[i]=1; printf("%s",kk->GL[i].vex);rear=rear+1; Q[rear]=i;}w=w->next;}}}void TRAVER1(FS *kk){ int i;for(i=0; i<kk->top;i++) visited[i]=0;for(i=0; i <kk->top;i++)if(visited[i]==0)BFS(kk,i);}int main(){int i=0;Graph *p;FS *q;while(i=1){/*建立菜单*/char jz[30]={"1.创建邻接矩阵"};char jd[30]={"2.邻接矩阵DFS遍历"};char jb[30]={"3.邻接矩阵BFS遍历"};char bg[30]={"4.创建邻接表"};char bd[30]={"5.邻接表DFS遍历"};char bb[30]={"6.邻接表BFS遍历"};char tc[30]={"7.退出"};char mn[30]={"菜单"};int l=strlen(jd);int o=strlen(mn);int m,n;printf("\n");for(m=0;m<=(2*l-o)/2;m++)printf(" ");printf("%s",mn);for(m=0;m<=(2*l-o)/2;m++)printf(" ");printf("\n");for(m=0;m<=2*l;m++)printf("*");printf("\n");printf("* %s *\n* %s*\n* %s *\n* %s *\n* %s *\n* %s *\n* %s*\n",jz,jd,jb,bg,bd,bb,tc);for(m=0;m<=2*l;m++)printf("*");printf("\n");/*选择功能*/printf("请输入所需功能序号: ");scanf("%d",&n);switch(n){case 1: p=Create_Graph();break;case 2: traver(p);break;case 3: traver1(p);break;case 4: q=CreateGL();break;case 5: TRAVER(q);break;case 6: TRAVER1(q);break;case 7: return 0;default:printf("输入功能序号有误！\n");}}return 0;}四、运行结果:在此把运行结果从屏幕上拷下来贴在此五、心得体会:测试数据要注意现实中矩阵是从1开始, 而数组里是从0开始。

数据结构C语言版——图的建立与遍历

}ArcNode;
typedef struct VNode{
VertexType data;
ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
typedef struct{
AdjList vertices;
int vexnum,arcnum;
int kind;
typedef int Status;
//图的邻接矩阵——数组存储表示-------------------------
#define INF0
typedef int VRType;
typedef char VertexType[20];
{
scanf("%s%s",v1,v2);
i=LocateVex(G,v1);
j=LocateVex(G,v2);
G->arcs[i][j].adj=1;
G->arcs[j][i]=G->arcs[i][j];
}
return(1);
}
int LocateVex(MGraph *G,VertexType v){
Boolean visited[MAX_VERTEX_NUM];
void Dfs(MGraph *G,int v)
{
int w;
visited[v]=TRUE;
printf("%s",G->vexs[v]);
for(w=FirstAdjVex(G,v); w>=0;w=NextAdjVex(G,v,w))
AdjMatrix arcs;
int vexnum,arcnum;
}MGraph;

数据结构实验报告-图的遍历

数据结构实验报告实验：图的遍历一、实验目的：1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表2、掌握图的构造方法3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法4、掌握图的深度优先遍历和广度优先原理二、实验内容：1、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接矩阵存储改图。

2、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接表存储该图3、深度优先遍历第一步中构造的图G，输出得到的节点序列4、广度优先遍历第一部中构造的图G，输出得到的节点序列三、实验要求：1、无向图中的相关信息要从终端以正确的方式输入；2、具体的输入和输出格式不限；3、算法要具有较好的健壮性，对错误操作要做适当处理；4、程序算法作简短的文字注释。

四、程序实现及结果：1、邻接矩阵：#include <stdio.h>#include <malloc.h>#define VERTEX_MAX 30#define MAXSIZE 20typedef struct{intarcs[VERTEX_MAX][VERTEX_MAX] ;int vexnum,arcnum;} MGraph; void creat_MGraph1(MGraph *g) { int i,j,k;int n,m;printf("请输入顶点数和边数:");scanf("%d%d",&n,&m);g->vexnum=n;g->arcnum=m;for (i=0;i<n;i++)for (j=0;j<n;j++)g->arcs[i][j]=0;while(1){printf("请输入一条边的两个顶点：\n");scanf("%d%d",&i,&j);if(i==-1 || j==-1)break;else if(i==j || i>=n || j>=n){printf("输入错误,请重新输入！\n");}else{g->arcs[i][j]=1;g->arcs[j][i]=1;}}}void printMG(MGraph *g) {int i,j;for (i=0;i<g->vexnum;i++){for (j=0;j<g->vexnum;j++)printf(" %d",g->arcs[i][j]);printf("\n");}printf("\n");}main(){int i,j;int fg;MGraph *g1;g1=(MGraph*)malloc(sizeof(MGraph));printf("1:创建无向图的邻接矩阵\n\n");creat_MGraph1(g1);printf("\n此图的邻接矩阵为：\n"); printMG(g1);}2、邻接链表:#include<stdio.h>#include<malloc.h>#define MAX_SIZE 10typedef struct node{int vertex;struct node *next;}node,adjlist[MAX_SIZE];adjlist g;int visited[MAX_SIZE+1];int que[MAX_SIZE+1];void creat(){int n,e;int i;int start,end;node *p,*q,*pp,*qq;printf("输入无向图的顶点数和边数:");scanf("%d%d",&n,&e);for(i = 1; i <= n ; i++){visited[i] = 0;g[i].vertex = i;g[i].next = NULL;}printf("依次输入边:\n");for(i = 1; i <= e ; i++){scanf("%d%d",&start,&end);p=(node *)malloc(sizeof(node));p->vertex = end;p->next = NULL;q = &g[start];while(q->next)q = q->next;q->next = p;p1=(node*)malloc(sizeof(node));p1->vertex = start;p1->next = NULL;q1 = &g[end];while(qq->next)q1 = q1->next;q1->next = p1;}}void bfs(int vi){int front,rear,v;node *p;front =0;rear = 1;visited[vi] = 1;que[0] = vi;printf("%d ",vi);while(front != rear){v = que[front];p = g[v].next;while(p){if(!visited[p->vertex]){visited[p->vertex]= 1;printf("%d",p->vertex);que[rear++] = p->vertex;}p = p->next;}front++;}}int main(){creat();bfs(1);printf("\n");return 0;}五．实验心得与体会：(1)通过这次实验，使我基本上掌握了图的存储和遍历，让我弄清楚了如何用邻接矩阵和邻接链表对图进行存储(2)深度优先遍历和广度优先遍历都有着各自的优点，通过程序逐步调试，可以慢慢的理解这两种遍历方法的内涵和巧妙之处。

C图的创建与遍历实验报告

实验五图的遍历及其应用实现一、实验目的1．熟悉图常用的存储结构。

2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。

3．会用图的遍历解决简单的实际问题。

二、需求分析很多问题都是建立在图的遍历的基础上实现的，所以必须有一个程序能够实现将图进行广度和深度遍历，必须对图的所有节点进行访问。

以无向图为例，以无向图的邻接表和邻接矩阵为存储结构，分别实现对图进行广度和深度遍历。

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

三、实验内容[题目一] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。

该程序包括图类型以及每一种操作的具体的函数定义和主函数。

提示：输入示例上图的顶点和边的信息输入数据为：5 7 DGA B C D EAB AE BC CD DA DB EC四、结构算法模块：typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;五、相关函数设计Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历BFSTraverse(ALGraph G)//有向图的广度遍历，从第v个顶点出发，v为顶点下标locatevex(ALGraph G,char v)//图的基本操作，寻找顶点位置的下标DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G六、程序流程图七、运行结果截图最初程序运行界面如下：输入图的先相关信息后运行结果(其中深度优先遍历的起点选择的是字符所在序列的序号，且0是起点)，一下是深度优先遍历时选择不同的起点所出现的最终运行结果：程序源代码：//图的邻接表表示：#include<iostream>#include<malloc.h>#include<queue>using namespace std;# define MAX_VEX_NUM 20//宏定义数组最大int visited[MAX_VEX_NUM];//设置标志数组queue<int>q;typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;ALGraph G;//申明一个无向图的邻接矩阵类型int locatevex(ALGraph G,char v)//图的基本操作，寻找顶点位置的下标{int i=0;while(i<G.vexnum && v!=G.vertices[i].data)i++;if(i<G.vexnum)return i;}void Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示{cout<<"请输入图的顶点数和弧数:"<<endl;cin>>G.vexnum;cin>>G.arcnum;char v1;char v2;int v1locate;int v2locate;ArcNode * p;cout<<"输入图的顶点信息"<<endl;for(int i=0;i<G.vexnum;i++)//构造表头向量{cin>>G.vertices[i].data;//输入顶点值G.vertices[i].firstarc=NULL;//初始化指针}cout<<"请输入从起点到终点的一条弧所对应的顶点"<<endl; for(int k=1;k<=G.arcnum;k++)//输入各弧并创建十字链表{cin>>v1>>v2;//输入一条弧的起点和终点v1locate=locatevex(G,v1);//确定v1在图G中位置v2locate=locatevex(G,v2);//确定v2在图G中位置p=new ArcNode;//假定有足够空间p->adjvex=v2locate;//有一条弧指向v2p->nextarc=G.vertices[v1locate].firstarc;//对弧节点赋值G.vertices[v1locate].firstarc=p;//完成在入弧和出弧链表的插入/*q=new ArcNode;q->adjvex=v1locate;q->nextarc=G.vertices[v2locate].firstarc;G.vertices[v2locate].firstarc=q;*/}}//Create_DGvoid DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G {visited[v]=1;//访问第v个节点cout<<G.vertices[v].data<<" ";//输出节点值for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc){if(!visited[p->adjvex])DFS(G,p->adjvex);//对v的尚未访问的邻接顶点p递归调用dfs}}//DFSvoid DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历{for(int i = 0;i < G.vexnum;i++)visited[i]=0; //访问数组初始化DFS(G,vex); //先对图从指定定点访问for(int v = 0;v < G.vexnum;v ++) //对可能出现的子图遍历if(!visited[v]) //对尚未访问的顶点调用dfsDFS(G,v);}//DFSTraverseint BFSTraverse(ALGraph G)//无向图的广度遍历，从第v个顶点出发，v 为顶点下标{for(int i = 0;i < G.vexnum;i++) //访问数组初始化visited[i]=0;q.empty();int v;int u;for(v=0;v<G.vexnum;v++)if(!visited[v])//v尚未被访问{visited[v]=1;cout<<G.vertices[v].data<<" ";q.push(v);//V入队列while(!q.empty()){u=q.front();//对头元素出队并置为uq.pop();for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc) if(!visited[p->adjvex])//p为u的尚未访问的邻接节点{visited[p->adjvex]=1;cout<<G.vertices[p->adjvex].data<<" "; q.push(p->adjvex);}//if}//while}//ifreturn 1;}//BFSTraversevoid main(){int a;Create_DG(G);cout<<"输入图深度遍历的起点"<<endl; cin>>a;cout<<"深度优先遍历"<<endl; DFSTraverse(G,a);cout<<endl;cout<<"广度优先遍历"<<endl; BFSTraverse(G);}。

【实验】数据结构图的遍历实验报告

【关键字】实验数据结构图的遍历实验报告篇一：【数据结构】图的保存和遍历实验报告《数据结构B》实验报告系计算机与电子专业级班姓名学号XX年1 0月9日1. 上机题目：图的保存和遍历2. 详细设计#include#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define error printf#define QueueSize 30typedef struct{char vexs[GRAPHMAX];int edges[GRAPHMAX][GRAPHMAX];int n,e;}MGraph;int visited[10];typedef struct{int front,rear,count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q){Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q){return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x){if(QueueFull(Q))error("Queue overflow");else{ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;}}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){ error("Queue underflow");return NULL;}else{ temp=Q->data[Q->front]; Q->count--;Q->front=(Q->front+1)%QueueSize;return temp;}}void CreateMGraph(MGraph *G){int i,j,k;char ch1,ch2;printf("\n\t\t请输入定点数，边数并按回车（格式如：3，4）：");scanf("%d,%d",&(G->n),&(G->e));for(i=0;in;i++){ getchar();printf("\n\t\t请输入第%d个定点数并按回车：",i+1);scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->edges[i][j]=0;for(k=0;ke;k++){ getchar();printf("\n\t\t请输入第%d条边的顶点序号（格式如：i,j）：",k+1); scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->edges[i][j]=1;}}void DFSM(MGraph *G,int i){int j;printf("\n\t\t深度优先遍历序列：%c\n",G->vexs[i]);visited[i]=TRUE;for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) ////////////////DFSM(G,j);}void BFSM(MGraph *G,int k){ int i,j;CirQueue Q;InitQueue(&Q);printf("\n\t\t广度优先遍历序列：%c\n",G->vexs[k]);visited[k]=TRUE;EnQueue(&Q,k);while(!QueueEmpty(&Q)){ i=DeQueue(&Q);for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1){ visited[j]=TRUE;EnQueue(&Q,j);}}}void DFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) DFSM(G,i);}void BFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) BFSM(G,i);}void main(){MGraph *G,a;char ch1;int i,j,ch2;G=&a;printf("\n\t\t建立一个有向图的邻接矩阵表示\n"); CreateMGraph(G);printf("\n\t\t已建立一个有向图的邻接矩阵保存\n"); for(i=0;in;i++){ printf("\n\t\t");for(j=0;jn;j++)printf("%5d",G->edges[i][j]);}getchar();ch1='y';while(ch1=='y'||ch1=='Y'){ printf("\n");printf("\n\t\t图的保存与遍历");printf("\n\t\t********************************"); printf("\n\t\t*1-----更新邻接矩阵*");printf("\n\t\t*2-----深度优先遍历*");printf("\n\t\t*3-----广度优先遍历*");printf("\n\t\t*0-----退出*");printf("\n\t\t********************************");}} printf("\n\t\t请选择菜单号（0----3）"); scanf("%d",&ch2); getchar(); switch(ch2) { case 1:CreateMGraph(G); printf("\n\t\t图的邻接矩阵保存建立完成\n");break; case 2:DFSTraverseM(G);break; case 3:BFSTraverseM(G);break; case 0:ch1='n';break; default:printf("\n\t\t输出错误！清重新输入！"); }3. 调试分析（1）调试过程中主要遇到哪些问题？是如何解决的？由于实习之初对邻接表的保存结构了解不是很清楚，所以在运行出了一个小错误，即在输出邻接表时，每个结点都少了一个邻接点。

图的建立和遍历--数据结构

//图的建立#include <stdio.h>#define MAX_VERTEX_NUM 20//图的数据结构typedef struct{int adj;int *info; //该弧相关信息的指针}AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];struct MGraph{char vertex[MAX_VERTEX_NUM];AdjMatrix arcs;int vexnum, arcnum;};//返回顶点在数组的下标int LocateVex(MGraph G,char v){int j=0,i;for(i=0;i<G.vexnum;++i)if(G.vertex[i]==v){j=i;break;}return j;}//创建无向图void CreateUDG(MGraph &G){int i,j,k;char v1,v2,t;printf("请输入无向图G的顶点数,边数:\n");scanf("%d%d",&G.vexnum,&G.arcnum);printf("请输入%d个顶点的值,空格隔开:\n",G.vexnum);for(i=0;i<G.vexnum;++i){scanf("%c%c",&t,&G.vertex[i]);}printf("请输入%d条边的顶点(如0 1):\n",G.arcnum);for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;++j){G.arcs[i][j].adj=0;}for(k=0;k<G.arcnum;++k){scanf("%c%c%c%c",&t,&v1,&t,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);G.arcs[i][j].adj=G.arcs[j][i].adj=1;}}//输出图的邻接矩阵void Display(MGraph G){int i,j;printf("该图的邻接矩阵为：\n");for(i=0;i<G.vexnum;++i){for(j=0;j<G.vexnum;++j)printf("%d ",G.arcs[i][j].adj);printf("\n");}}//主函数int main(){MGraph G;CreateUDG(G);Display(G);return 0;}//图的遍历#include<stdio.h>#include<malloc.h>#define MaxVerNum 50struct edgenode{int endver; //该边所指向的顶点的位置int inform;edgenode* edgenext;//指向下一条边的指针};struct vexnode{char vertex; //顶点信息（字符型）edgenode* edgelink;//指向第一条依附于该顶点的指针};struct Graph //图信息{vexnode adjlists[MaxVerNum];int vexnum,arcnum;//无向图的当前顶点和边数};struct QueueNode{//队列的定义及相关函数的实现int data;QueueNode* next;};struct QueueList{QueueNode* front;QueueNode* rear;};void EnQueue(QueueList* Q,int e){*q=(QueueNode *)malloc(sizeof(QueueNode));q->data=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->data;Q->front=Q->rear=NULL;}else{*e=Q->front->data;Q->front=Q->front->next;}}void CreatAdjList(Graph* G)//创建图{int i,j,k;edgenode* p1;edgenode* p2;printf("请输入顶点数和边数:\n");scanf("%d,%d",&G->vexnum,&G->arcnum);printf("开始输入顶点信息:\n");for (i=0;i<G->vexnum;i++){scanf("%d",&G->adjlists[i].vertex);G->adjlists[i].edgelink=NULL;}printf("开始输入边表信息:\n");for (k=0;k<G->arcnum;k++){printf("请输入边<Vi,Vj>对应的顶点:");scanf("%d,%d",&i,&j);p1 =(edgenode *)malloc(sizeof(edgenode));p1->endver=j;//endve指该边所指向的顶点的位置p1->edgenext=G->adjlists[i].edgelink;//edgenext指向下一条边的指针G->adjlists[i].edgelink=p1;// edgelink指向第一条依附于该顶点的指针p2 =(edgenode *)malloc(sizeof(edgenode));p2->endver=i;p2->edgenext=G->adjlists[j].edgelink;G->adjlists[j].edgelink=p2;//因为是无向图，所以有两次建立边表的过程}void PrintGaph(Graph * G)//无向图的邻接表的输出{edgenode *p;for(int k=1;k<=G->vexnum;k++){printf("%d",G->adjlists[k]. vertex);p=G->adjlists[k].edgelink;while(p!=NULL){printf("%d",p->endver);p=p->edgenext;if(p!=NULL)printf("->");}printf("\n");}}void DFS(Graph *G,int i,int visit[]) //深度优先遍历,从第v个顶点出发递归地深度优先遍历无向图G{printf("%d",G->adjlists[i].vertex);printf(" ");visit[i]=1; //设置访问标志数组，未访问为0，访问后后为1edgenode *p=new edgenode;p=G->adjlists[i].edgelink; //指向第一条依附于该顶点vi的边的指针if(G->adjlists[i].edgelink&&!visit[p->endver]){ //指向第一条依附于该顶点vi 的便得指针非空，且顶点位被访问DFS(G,p->endver,visit); //递归自我调用}}void DFStraversal(Graph *G,char c) //深度优先遍历结果输出{printf("该图的深度优先遍历结果为:\n");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);}printf("\n");}void BFS(Graph* G,int v,int visit[])//广度优先遍历{QueueList *Q=new QueueList;Q->front=Q->rear=NULL;//初始化队列EnQueue(Q,v);//v入队列while(Q->rear!=NULL){int e=0;DeQueue(Q,&e);//对头（指定的）元素出队并设置为eprintf("%d",G->adjlists[e].vertex);//输出定点信息printf(" ");visit[e]=1;edgenode* p =(edgenode *)malloc(sizeof(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){printf("该图的广度优先遍历结果为:\n");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);}printf("\n");}void main(){Graph * G=(Graph *)malloc(sizeof(Graph));CreatAdjList(G);// PrintGaph(G);char ch;printf("请输入开始遍历的顶点:\n");scanf("%d",&ch);DFStraversal(G,ch);BFStraversal(G,ch); }。

数据结构(C语言版) 第七章图

路径与连通性
路径、简单路径、回路(环)、简单回路
顶点之间的连通性、无向连通图、有向强连通
图
4/46
7.1 图的定义和术语(3)
路径与连通性
对于有向图G1
V1V3V4V1V2 是从V1 到V2 的路径, 不是简单路径；
V1V2是简单路径; V1V3V4V1V3V4V1是环,不是简单环; V1V3V4V1是简单环。
3/46
7.1 图的定义和术语(2)
有向图
弧<v,w> ∊ E (v,w ∊V)，w为弧头, v为弧尾; 顶点v
邻接到顶点w，顶点w 邻接自顶点v，弧< v, w >和顶点v、w相关联。
顶点v 的入度是以v 为弧头的弧的数目,记为ID(v); v 的出度是以v为弧尾的弧的数目,记为OD(v); v 的度是TD(v) = ID(v) + OD(v)。
}VNode, AdjList[MAX_VERTEX_NUM];
这种存储结构适合于进行first_adj(G,v) 找v的第一个邻接点的操作
邻接矩阵的方法适合存储稠密图
26/46
7.2.2 邻接表--- 链式存储结构
邻接表是一种顺序存储与链式结构相结合的存储方式，类似于树的孩子链表。
对每个顶点建立一个单链表，第i个单链表中的结点表示依附于顶点vi的边。
邻接矩阵
从邻接矩阵M中可以看出该图共有（）个顶点；如果是有向图该图共有（）条弧，如果是无向图，则共有（）边。
AB CD
G
25/46
邻接矩阵存储的特点
无向图的邻接矩阵是对称的，对n个顶点的无向图只需要存入下三角矩阵，即需要n(n-1)/2个存储单元。
有向图的邻接矩阵所需要的存储单元不一定，需要N*N个存储单元

数据结构C语言实现图的建立,图的广度,深度遍历

图的建立，图的广度，深度遍历#include "stdio.h"#define maxsize 1000# define n 100typedef struct{ char vexs[n] ;int arcs[n][n] ;int num ;}G;typedef struct{int data[maxsize];int front,rear;} V;void GInit(G *L){L->num=0;}int GVexs(G *L){return(L->num);}void GCreate(G *L){int i,j;GInit(L);printf("请输入顶点数目：\n");scanf("%d",&L->num);printf("请输入各顶点：\n");for(i=0;i<L->num;i++){fflush(stdin);scanf("%c",&L->vexs[i]);}printf("请输入各顶点边的关系（1是有关0是无关）：\n"); for(i=0;i<L->num;i++){for(j=0;j<L->num;j++){scanf("%d",&L->arcs[i][j]);}}}void GOut(G L){int i,j;printf("\n图的顶点数目为：%d",L.num); printf("\n图的各顶点的信息为：\n");for(i=0;i<L.num;i++)printf("%7c",L.vexs[i]);printf("\n");for(i=0;i<L.num;i++){for(j=0;j<L.num;j++){printf("%7d ",L.arcs[i][j]);}printf("\n");}}void DFS(G g,int qidian,int mark[]){int v1;mark[qidian]=1;printf("%c ",g.vexs[qidian]);for(v1=0;v1<g.num;v1++){if(g.arcs[qidian][v1]!=0&&mark[v1]==0) DFS(g,v1,mark);}}void GDFS(G g){int qidian,v,v1,mark[maxsize];printf("\n深度遍历：");printf("\n请输入起点的下标：");scanf("%d",&qidian);getchar();for(v=0;v<g.num;v++){mark[v]=0;}for(v=qidian;v<g.num+qidian;v++){v1=v%g.num;if(mark[v1]==0)DFS(g,v1,mark);}}void QueueInit(V *sq){sq->front=0;sq->rear=0;}int QueueIsEmpty(V sq){if (sq.rear==sq.front)return(1);elsereturn(0);}int QueueFront(V sq, int *e){if (QueueIsEmpty(sq)){ printf("queue is empty!\n");return 0;} else{ *e=sq.data[(sq.front)]; return 1;}}int QueueIn (V *sq, int x){if (sq->front==(sq->rear+1)%maxsize) {printf("queue is full!\n");return 0;}else{sq->data[sq->rear]=x;sq->rear=(sq->rear+1)%maxsize; return(1);}}int QueueOut(V *sq){if (QueueIsEmpty(*sq)){printf("queue is empty!\n"); return 0;}else{sq->front=(sq->front+1)%maxsize; return 1;}}void BFS(G g,int v,int mark[]){int v1,v2;V q;QueueInit(&q);QueueIn(&q,v);mark[v]=1;printf("%c ",g.vexs[v]);while(QueueIsEmpty(q)==0){QueueFront(q,&v1);QueueOut(&q);for(v2=0;v2<g.num;v2++)if(g.arcs[v1][v2]!=0&&mark[v2]==0) {QueueIn(&q,v2);mark[v2]=1;printf("%c ",g.vexs[v2]);}}}}void GBFS(G g){int qidian,v,v1,mark[maxsize];printf("\n广度遍历：");printf("\n");scanf("%d",&qidian);for(v=0;v<g.num;v++){mark[v]=0;}for(v=qidian;v<g.num+qidian;v++) {v1=v%g.num;if(mark[v1]==0)BFS(g,v1,mark);}}void main(){G tu;GCreate(&tu);GOut(tu);GDFS(tu);GBFS(tu);}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验五（1）：图的创建与遍历
1．实验目的：
1．掌握图的含义；
2．掌握用邻接矩阵和邻接表的方法描述图的存储结构；
3．理解并掌握深度优先遍历和广度优先遍历的存储结构。

2．实验内容：
（1）以邻接矩阵为存储结构，实现连通有向图（下图）的所有顶点出度与入度的计算。

（2）设计两个算法分别实现深度优先遍历和广度优先遍历。

1 调试程序。

设计一个有向图和一个无向图，任选一种存储结构，完成有向
图和无向图的DFS（深度优先遍历）和BFS（广度优先遍历）的操作。

邻接矩阵作为存储结构的运行结果：
邻接链表作为存储结构的运行结果：
实验报告要求
画出你所设计的图，写出两种方法的遍历序列。

邻接矩阵：
V0 V1 V2 V3 V4 V5 V6 V7
V0 0 1 1 0 0 0 0 0 V1 1 0 0 1 1 0 0 0 V2 1 0 0 0 0 1 1 0 V3 0 1 0 0 0 0 0 1 V4 1 0 0 0 0 0 0 1 V5 0 1 0 0 0 0 1 0 V6 0 1 0 0 0 1 0 0 V7 0
1
1
V6 V4 V5 V7 V2 V3 V1 V0 图G 的示例
V0 0 2 1 ^
V1 1 4 3 ^ 0 ^ V2 2 6 5 0 ^ V3 3 4 1 ^
V4 4 7 1 ^
V5 5 6 2 ^
V6 6 5 2 ^
V7 7 4 3 ^
深度遍历为：0→2→6→5→1→4→7→3
广度遍历为：3→7→1→4→0→2→6→5。