图的邻接表存储结构实验报告
图的存储结构与遍历 数据结构实验
实验报告June 11 2015姓名：陈斌学号：E11314079 专业：13计算机科学与技术数据结构第七次实验学号E11314079专业计算机科学与技术姓名陈斌实验日期2015.06.11教师签字成绩实验报告【实验名称】图的存储结构与遍历【实验目的】(1)掌握图的相关概念；(2)掌握图的存储结构；(3)掌握图的遍历算法并编程实现。
【实验内容】编写一个程序，实现图的相关运算，并在此基础上设计一个主程序，完成如下功能：(1)建立如教材图7.9所示的有向图G的邻接矩阵，并分别输出顶点表和邻接矩阵。
(2)由有向图G的邻接矩阵产生邻接表，并依次输出每一顶点和其邻接表。
(3)再由（2）的邻接表产生对应的邻接矩阵，并输出该矩阵。
(4)在图G的邻接矩阵存储表示基础上，输出从顶点V1开始的深度优先遍历序列（递归算法）。
(5)在图G的邻接表存储表示基础上，输出从顶点V1开始的广度优先遍历序列。
(6)利用非递归算法重解任务（4）（选做）。
源代码：head.h:#include<string.h>#include<ctype.h>#include<malloc.h> //malloc( )#include<limits.h> // INT ,MAX#include<stdio.h> //EOF,NULL#include<stdlib.h> //atoi( )#include<io.h> //eof( )#include<math.h> //floor( ),ceil( ),abs( )#include<process.h> //exit( )#include<iostream.h> //cout,cin//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1//OVERFLOW 在math.h中已定义为3typedefint Status;typedefint Boolean; // 布尔类型main.cpp:#include"head.h"#define MAX_NAME 5 /* 顶点字符串的最大长度+1 */#define MAX_INFO 20 /* 相关信息字符串的最大长度+1 */typedefintVRType;typedefintInfoType;typedef char VertexType[MAX_NAME];#define INFINITY INT_MAX /* 用整型最大值代替∞*/#define MAX_VERTEX_NUM 20 /* 最大顶点个数*/typedefenum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} *//*图的数组(邻接矩阵)存储表示*/typedefstruct{VRTypeadj; /* 顶点关系类型。
图的邻接表存储结构实验报告
《图的邻接表存储结构实验报告》1.需解决的的问题利用邻接表存储结果，设计一种图。
2.数据结构的定义typedef struct node{//边表结点int adj;//边表结点数据域struct node *next;}node;typedef struct vnode{//顶点表结点char name[20];node *fnext;}vnode,AList[M];typedef struct{AList List;//邻接表int v,e;//顶点树和边数}*Graph;3.程序的结构图4.函数的功能1）建立无向邻接表Graph Create1( )//建立无向邻接表{Graph G;int i,j,k;node *s;G=malloc(M*sizeof(vnode));printf("输入图的顶点数和边数：");scanf("%d%d",&G->v,&G->e);//读入顶点数和边数for(i=0;i<G->v;i++)//建立顶点表{ printf("请输入图第%d个元素:",i+1);scanf("%s",&G->List[i].name);//读入顶点信息G->List[i].fnext=NULL;//边表置为空表}for(k=0;k<G->e;k++)//建立边表--建立了2倍边的结点{ printf("请输入边的两顶点序号：（从0考试）");scanf("%d%d",&i,&j);//读入边（Vi,Vj）的顶点对序号s=(node *)malloc(sizeof(node));//生成边表结点s->adj=j;s->next=G->List[i].fnext;G->List[i].fnext=s;//将新结点*s插入顶点Vi的边表头部s=(node *)malloc(sizeof(node));s->adj=i;//邻接点序号为is->next=G->List[j].fnext;G->List[j].fnext=s;// 将新结点*s插入顶点Vj的边表头部}return G;}2）建立有向邻接图Graph Create2() //有向邻接图{Graph G;int i,j,k;node *q;G=malloc(M*sizeof(vnode));printf("请输入顶点数和弧数：");scanf("%d%d",&G->v,&G->e);for (i=0;i<G->v;i++) //建立有n个顶点的顶点表{ printf("请输入图第%d个元素：",i+1);scanf("%s",&G->List[i].name); //读入顶点信息G->List[i].fnext=NULL;}for (k=0;k<G->e;k++) //建立边表{ printf("请输入两顶点的序号：（从0开始）");scanf("%d%d",&i,&j);q=(node *)malloc(sizeof(node)); //生成新边表结点sq->adj=j; //邻接点序号为jq->next=G->List[i].fnext;G->List[i].fnext=q;}return G;}3）输出无向图的邻接表void Print1(Graph G)//输出无向图的邻接表{int i;node *p;printf("\n\t\t\t邻接表\n");for(i=0;i<G->v;i++){ p=G->List[i].fnext;printf("\t\t\t%d | %3s",i,G->List[i].name);while(p){printf("->%d",p->adj);p=p->next;}printf("\n");}}4）输出个元素的度数void Du(Graph G)//输出各元素的度数{int i,j;node *p;printf("\n\t\t\t各点度数\n");for(i=0;i<G->v;i++){ p=G->List[i].fnext;printf("\t\t\t顶点%2s的度为：",G->List[i].name);j=0;while(p){ j++;p=p->next;}printf("%d\n",j);}}5）返回图结点在的序号int LocateVex(Graph G,char *u){//初始条件：图G存在，u和G中顶点有相同的特征//操作结果：若G中存在顶点u，则返回该顶点在图中的位置;否则返回-1 int i;for(i=0;i<G->v;++i)if(strcmp(u,G->List[i].name)==0)return -1;}6）返回序号为v的图结点的值char *VertexGet(Graph G,int v){if(v>=G->v||v<0)exit(0);return G->List[v].name;}7）返回图结点v的第一个邻接顶点的序号int FirstAdjVex(Graph G,char *v){//初始条件：图G存在，v是G中的某个顶点//操作结果：返回v中第一个邻接顶点的序号。
数据结构_实验五_报告
实验报告实验五图的遍历及其应用实现一、实验目的1．熟悉图常用的存储结构。
2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。
3．会用图的遍历解决简单的实际问题。
二、实验内容[题目一] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。
该程序包括图类型以及每一种操作的具体的函数定义和主函数。
[题目二]：在图G中求一条从顶点 i 到顶点 s 的简单路径设计要求：1、上机前，认真学习教材，熟练掌握图的构造和遍历算法,图的存储结构也可使用邻接矩阵等其他结构.2、上机前，认真独立地写出本次程序清单，流程图。
图的构造和遍历算法分别参阅讲义和参考教材事例三、实验步骤㈠、数据结构与核心算法的设计描述#define MAX_VERTEX_NUM 20//变量声明typedef struct ArcNode//弧结点定义{int adjvex; //该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针//InfoType *info;}ArcNode;typedef struct VNode//顶点结点定义{char data; //顶点信息ArcNode *firstarc; //指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];typedef struct//图的定义{AdjList vertices;int vexnum,arcnum; //图的当前顶点数和弧数int kind; //图的种类标志}ALGraph;ALGraph G; //定义图变量bool visited[MAX_VERTEX_NUM]; //访问标志数组typedef struct QueueNode//队列结点类型定义{int data; //结点中所存值QueueNode *next; //指向下一个结点}QueueNode;typedef struct//队列定义{QueueNode *first; //队列的头指针QueueNode *rear; //队列的尾指针}QueueLink;相关函数声明：void CreateGraph(MGraph &G)// 输入图的顶点和边的信息,建立图void DFSTraverse(Graph G, int v)//深度优先搜索遍历图void BFSTraverse(Graph G, int v)//广度优先搜索遍历图int LocateVertices(ALGraph G,char a)//查找字符a在图中的位置int FirstAdjVex(ALGraph G,int v)//查找图中位置v的第一个邻接点在图中所在的位置int NextAdjVex(ALGraph G,int v,int w)//查找相对于图中位置v的邻接点w的下一邻接点在图中的位置void DestroyGraph(ALGraph &G)//销毁图void DFS(ALGraph G,int v)//利用递归实现对图中一个极大强连通分量的遍历void DFSTraverse(ALGraph G)//深度遍历访问图void InitQueue(QueueLink &Queue)//初始化队列void EnQueue(QueueLink &Queue,int i)//元素i入队列void DeQueue(QueueLink &Queue,int &i)//队列头元素出队int QueueEmpty(QueueLink Queue)//判断队列是否为空，若为空则返回1，否则返回0void DestroyQueue(QueueLink &Queue)//销毁队列void BFSTraverse(ALGraph G)//利用队列实现图的广度优先遍历㈢程序调试及运行结果分析在调试过程中，LocateVertices(ALGraph G,char a)函数中少了一个return -1语句，经过修改得到正确的结果。
实验六 图的邻接表存储及遍历
}
printf("\n"); /* 换行 */
}
}
{
printf("顶点%d =>",head[i].vertex);/* 顶点值 */
ptr = head[i].nextnode; /* 顶点位置 */
while ( ptr != NULL ) /* 遍历至链表尾 */
{
printf(" %d ",ptr->vertex); /* 输出顶点内容 */
2）当队列非空时重复做：
（1）取பைடு நூலகம்首顶点；
（2）对与队首顶点邻接的所有未被访问的顶点依次做：
打印该顶点；
置顶点为“已访问”标志；
该顶点入队；
否则，当前队首顶点出队。
3) 结束。
三、目的要求
1．掌握图的基本存储方法；
2．掌握有关图的操作算法并用高级语言实现；
3．熟练掌握图的两种搜索路径的遍历方法。
四、实验内容
1．编写程序实现下图的邻接表表示及其基础上的深度和广度优先遍历。
五、程序实例
图的邻接表表示法的C语言描述：
#include <stdlib.h>
#include <stdio.h>
struct node /* 图形顶点结构定义 */
{
int vertex; /* 顶点 */
struct node *nextnode; /* 指下一顶点的指针 */
};
typedef struct node *graph;
struct node head[vertexnum];
数据结构课程实验(图的存储与遍历)
实验五图的存储与遍历1、实验目的掌握图这种复杂的非线性结构的邻接矩阵和邻接表的存储表示，以及在此两种常用存储方式下深度优先遍历(dfs)和广度优先遍历（BFS）操作的实现。
2、实验预备知识（1）图的存储结构：邻接矩阵表示法和邻接表表示法。
邻接矩阵表示法除了要用一个二维数组存储用于表示顶点间相邻关系的邻接矩阵外，还需用一个一维数组来存储顶点信息，另外还有图的顶点数和边数。
邻接表表示法类似于树的孩子链表表示法。
（2）图的遍历方法有深度优先遍历（Depth－First Traersal）和广度优先遍历（Breadth－First Traversal），简称 DFS和BFS。
DFS对图遍历时尽可能先对纵深方向进行搜索；BFS是类似于树的按层次遍历。
3、实验内容题目1对以邻接矩阵为存储结构的图进行 DFS和 BFS遍历(1) 问题描述：以邻接矩阵为图的存储结构，实现图的DFS和BFS遍历。
(2) 基本要求：建立一个图的邻接矩阵表示，输出顶点的一种DFS和BFS序列。
(3) 测试数据：如图4．18所示。
(4) 实现提示：图的DFS遍历可通过递归调用或用栈来实现。
其思想是：只要当前结点未访问过，就访问该结点，沿着其一条分支深入下去，每深入一个未访问过的结点，就访问这个结点，然后从这个结点继续进行DFS遍历。
在这一过程中，若深入时遇到一个已访问过的结点，则查找是否有与这个结点相邻的下一个未访问过的结点。
若有则继续深人，否则将退回到这个结点的前一个结点，再找下一个相邻的本访问过的结点，……如此进行下去，直到所有的结点都被访问过。
BFS遍历可利用队列来帮助实现，也可以用栈。
实现方法与二叉树的层次遍历类似。
题目2对以邻接表为存储结构的图进行DFS和BFS遍历(1) 问题描述：以邻接表为存储结构，实现图的DFS和BFS遍历。
(2) 基本要求：建立一个图的邻接表存储，输出顶点的一种DFS和BFS序列。
(3) 测试数据：如图4.19所示：(4) 实现提示：以邻接表为存储结构的图的DFS和BFS算法的实现思想与以邻接矩阵为存储结构的实现是一样的。
数据结构与算法-图的邻接表
数据结构与算法-图的邻接表实验报告课程: 数据结构与算法实验日期: 实验名称: 图的邻接表一、实验目的掌握图的邻接表的创建和遍历二、实验内容必做部分1、给出图的邻接表存储结构的类型定义。
2、设计并实现以邻接表的方式构造一个无向网的算法。
Status CreateUDN(ALGraph &G) 3、设计并实现无向网的输出算法，要求能显示顶点以及顶点之间的邻接关系(方式自定) 4、基于邻接表方式实现:a) int FirstAdjVex(ALGraph G,int v) //返回v的第一个邻接点的下标，若不存在，则返回-1 b) int NextAdjVex(ALGraph G,int v,int w) // 返回v相对于w的下一个邻接点，若不存在，则返回-15、基于邻接表存储结构实现图的深度优先搜索算法。
void DFSTraverse(ALGraph G)6、在主函数中调用上述操作函数。
要求给出至少两组测试数据。
选做部分基于邻接表存储结构实现图的广度优先搜索算法。
三、实验步骤必做部分1、给出图的邻接表存储结构的类型定义。
12、设计并实现以邻接表的方式构造一个无向网的算法。
Status CreateUDN(ALGraph &G)3、设计并实现无向网的输出算法，要求能显示顶点以及顶点之间的邻接关系(方式自定)24、基于邻接表方式实现:a) int FirstAdjVex(ALGraph G,int v) //返回v的第一个邻接点的下标，若不存在，则返回-1b) int NextAdjVex(ALGraph G,int v,int w) // 返回v相对于w的下一个邻接点，若不存在，则返回-135、基于邻接表存储结构实现图的深度优先搜索算法。
void DFSTraverse(ALGraph G)6、在主函数中调用上述操作函数。
要求给出至少两组测试数据。
选做部分基于邻接表存储结构实现图的广度优先搜索算法。
数据结构实验报告
数据结构实验报告（实验五&&实验六）班级：软件121学号：201200834122姓名：程猛实验五图的基本操作1.问题描述：以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
2.算法设计：以邻接表存储图的结构，建立一个图的类，并且用数组visited[i]标记该节点是否被访问。
并由临接表建立邻接矩阵。
再由输入的k值确定访问的起始点。
报错机制，当输入的数据，不符合要求时，会提醒。
3.测试数据：图的点数：5图的总边数：5边的起点和终点序号：1 2 2 3 3 4 4 04.源代码：#include"stdafx.h"#include<iostream>#include<iomanip>using namespace std;#include<stdlib.h>const int MaxV=10;//最多顶点数//定义邻接表中的边节点类型struct edgenode{int adjvex; //邻接点域edgenode* next;//指向下一个边节点的链域};//定义邻接表的类型typedef edgenode** adjlist;//邻接矩阵类的定义class AdjMatrix{private:char g[MaxV]; //顶点信息数组int size; //当前顶点数int GA[MaxV][MaxV];//定义邻接矩阵GAint numE;//当前边数public://构造函数，初始化图的邻接矩阵AdjMatrix(int n);//判断图空否bool GraphEmpty() {return size==0;}//取当前顶点数int NumV() {return size;}//取当前边数int NumEdges() {return numE;}//取顶点i的值char GetValue(const int i);//取弧<v1,v2>的权int GetWeight(const int v1,const int v2);//在位置pos处插入顶点vvoid InsertV(const char &V,int pos);//插入弧<v1，v2>权为weightvoid InsertEdge(const int v1,const int v2,int weight);//建立弧的邻接矩阵void CreateMatrix(int n);//k1为则无向否则为有向k2为则有权，否则无权//从初始点vi出发深度优先搜索由邻接矩阵表示的图void dfsMatrix(bool * &visited,int i,int n);//从初始点vi出发广度优先搜索由邻接矩阵表示的图void bfsMatrix(bool * &visited,int i,int n);//由图的邻接矩阵的到图的邻接表void graphChange(adjlist &GL,int n);//检查输入的边序号是否越界，否则重新输入void check(int n,int & i,int & j);//由图的邻接矩阵建立图void Creategraph(int n);//对非连通图进行深度优先搜索void dfsMatrix(int n);//对非连通图进行广度优先搜索void bfsMatrix(int n);};AdjMatrix::AdjMatrix(int n){int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++)GA[i][j]=0;size=numE=0;}//建立图的邻接矩阵void AdjMatrix::CreateMatrix(int n){int i,j,k,e;cout<<"输入图的总边数：";cin>>e;cout<<"输入"<<e<<"条无向无权边的起点和终点序号："<<endl;for(k=1;k<=e;k++){cin>>i>>j;check(n,i,j);GA[i][j]=GA[j][i]=1;}numE=e;cout<<"创建后的邻接矩阵："<<endl;for(i=0;i<n;i++){for(j=0;j<n;j++)cout<<setw(4)<<GA[i][j];cout<<endl;}}void AdjMatrix::dfsMatrix(bool*& visited,int i,int n){cout<<g[i]<<':'<<i<<" ";visited[i]=true;for(int j=0;j<n;j++)if(i!=j&&GA[i][j]!=0&&!visited[j])dfsMatrix(visited,j,n);}void AdjMatrix::bfsMatrix(bool*& visited,int i,int n){const int MaxLength=30;int q[MaxLength]={0};int front=0,rear=0;cout<<g[i]<<':'<<i<<" ";visited[i]=true;q[++rear]=i;while(front!=rear){front=(front+1)%MaxLength;int k=q[front];for(int j=0;j<n;j++)if(k!=j&&GA[k][j]!=0&&!visited[j]){cout<<g[j]<<':'<<j<<" ";visited[j]=true;rear=(rear+1)%MaxLength;q[rear]=j;}}}void AdjMatrix::check(int n,int& i,int& j){while(1){if(i<0||i>=n||j<0||j>=n)cout<<"输入有误，请重输！";elsereturn;cin>>i>>j;}}void AdjMatrix::graphChange(adjlist &GL,int n) {int i,j;for(i=0;i<n;i++){for(j=0;j<n;j++)if(GA[i][j]!=0){edgenode*p=new edgenode;p->adjvex=j;p->next=GL[i];GL[i]=p;cout<<'('<<i<<','<<p->adjvex<<") ";}cout<<endl;}}void AdjMatrix::Creategraph(int n){int i,j,k,m=0;for(i=0;i<n;i++){k=i;for(j=0;j<n;j++)if(GA[i][j]!=0)if(k==i&&m<n){g[m]='A'+m;size++;cout<<g[m]<<'('<<i<<','<<j<<") ";m++;}}cout<<endl;g[n]='\0';}char AdjMatrix::GetValue(const int i){if(i<0||i>size){cerr<<"参数i越界"<<endl;exit(1);}return g[i];}int AdjMatrix::GetWeight(const int v1,const int v2) {if(v1<0||v1>size||v2<0||v2>size){cerr<<"参数v1或v2越界！"<<endl;exit(1);}return GA[v1][v2];}void AdjMatrix::InsertV(const char &V,int pos){int i;if(size==MaxV){cerr<<"表已满，无法插入！"<<endl;exit(1);}if(pos<0||pos>size){cerr<<"参数pos越界！"<<endl;exit(1);}for(i=size;i>pos;i--)g[i]=g[i-1];g[pos]=V;size++;}void AdjMatrix::InsertEdge(const int v1,const int v2,int weight) {if(v1<0||v1>size||v2<0||v2>size){cerr<<"参数v1或v2越界"<<endl;exit(1);}GA[v1][v2]=weight;numE++;}void AdjMatrix::dfsMatrix(int n){int i;bool *vis=new bool[NumV()];for( i=0;i<NumV();i++)vis[i]=false;for(i=0;i<NumV();i++)if(!vis[i])dfsMatrix(vis,i,n);delete []vis;}void AdjMatrix::bfsMatrix(int n){int i;bool *vis=new bool[NumV()];for( i=0;i<NumV();i++)vis[i]=false;for(i=0;i<NumV();i++)if(!vis[i])bfsMatrix(vis,i,n);delete []vis;}int _tmain(int argc, _TCHAR* argv[]) {int n,k,i;bool *vis;adjlist Al;cout<<"输入图的点数n=";cin>>n;Al=new edgenode*[n];vis=new bool[n];if(!vis){cout<<"申请堆内存失败！"<<endl;exit(1);}for(i=0;i<n;i++){vis[i]=false;}AdjMatrix A(n);A.CreateMatrix(n);cout<<"出发点vk的序号=";cin>>k;cout<<endl<<"输出邻接矩阵相应图的顶点"<<endl;A.Creategraph(n);cout<<"图的深度优先搜索顺序："<<endl;A.dfsMatrix(vis,k,n);for(i=0;i<n;i++)vis[i]=false;cout<<endl<<"图的广度优先搜索顺序："<<endl;A.bfsMatrix(vis,k,n);cout<<endl<<"输出邻接表的每个邻接点"<<endl;for(i=0;i<n;i++)vis[i]=false;A.graphChange(Al,n);delete []vis;return 0;}5.结果和分析：图的点数序列从零开始。
2-深度优先遍历以邻接表存储的图-实验报告
福建江夏学院《数据结构与关系数据库（本科）》实验报告姓名班级学号实验日期课程名称数据结构与关系数据库（本科）指导教师成绩实验名称：深度优先遍历以邻接表存储的图一、实验目的1、掌握以邻接表存储的图的深度优先遍历算法；二、实验环境1、硬件环境：微机2、软件环境：Windows XP，VC6.0三、实验内容、步骤及结果1、实验内容：基于图的深度优先遍历编写一个算法，判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径（i≠j）。
2、代码：#include <stdio.h>#include <stdlib.h>#define MaxVertexNum 100 /*最大顶点数为100*/typedef char VertexType;typedef struct node{ /*边表结点*/int adjvex; /*邻接点域*/struct node * next; /*指向下一个邻接点的指针域*//*若要表示边上信息，则应增加一个数据域info*/}EdgeNode;typedef struct vnode{ /*顶点表结点*/VertexType vertex; /*顶点域*/EdgeNode * firstedge; /*边表头指针*/}VertexNode;typedef VertexNode AdjList[MaxVertexNum]; /*AdjList 是邻接表类型*/typedef struct{AdjList adjlist; /*邻接表*/int n,e; /*顶点数和边数*/}ALGraph; /*ALGraph 是以邻接表方式存储的图类型*/bool visited[MaxVertexNum];void CreateALGraph(ALGraph *G){/*建立有向图的邻接表存储*/int i,j,k;EdgeNode * s;printf("请输入顶点数和边数(输入格式为:顶点数,边数)：\n");scanf("%d,%d",&(G->n),&(G->e)); /*读入顶点数和边数*/printf("请输入顶点信息(输入格式为:顶点号<CR>)：\n");for (i=0;i<G->n;i++) /*建立有n 个顶点的顶点表*/{scanf("\n%c",&(G->adjlist[i].vertex)); /*读入顶点信息*/G->adjlist[i].firstedge=NULL; /*顶点的边表头指针设为空*/}printf("请输入边的信息(输入格式为:i,j)：\n");for (k=0;k<G->e;k++) /*建立边表*/{scanf("\n%d,%d",&i,&j); /*读入边<Vi,Vj>的顶点对应序号*/s=(EdgeNode*)malloc(sizeof(EdgeNode)); /*生成新边表结点s*/s->adjvex=j; /*邻接点序号为j*/s->next=G->adjlist[i].firstedge; /*将新边表结点s 插入到顶点Vi 的边表头部*/G->adjlist[i].firstedge=s;}}/*CreateALGraph*/void DFSAL(ALGraph *G,int i){/*以Vi 为出发点对邻接表存储的图G 进行DFS 搜索*/EdgeNode *p;printf("visit vertex:V%c\n",G->adjlist[i].vertex);/*访问顶点Vi*/visited[i]=true; /*标记Vi 已访问*/p=G->adjlist[i].firstedge; /*取Vi 边表的头指针*/while(p) /*依次搜索Vi 的邻接点Vj，j=p->adjva*/{if (!visited[p->adjvex]) /*若Vj 尚未访问，则以Vj 为出发点向纵深搜索*/ DFSAL(G,p->adjvex);p=p->next; /*找Vi 的下一个邻接点*/}}/*DFSAL*/void DFSTraverseAL(ALGraph *G){/*深度优先遍历以邻接表存储的图G*/int i;for (i=0;i<G->n;i++)visited[i]=false; /*标志向量初始化*/for (i=0;i<G->n;i++)if (!visited[i]) DFSAL(G,i); /*vi 未访问过，从vi 开始DFS 搜索*/}/*DFSTraveseAL*/void main(){ALGraph *G;G=(ALGraph *)malloc(sizeof(ALGraph));CreateALGraph(G);printf("深度优先搜索结果：\n");DFSTraverseAL(G);}3、测试数据与实验结果分析（可以用组合键Alt+Print Screen截图）：四、心得体会。
实验报告：图的存储结构和遍历
武汉东湖学院
实验报告
学院：计算机科学学院专业计算机科学与技术2016年11月18日
姓名付磊学号42
班级计科一班指导老师吴佳芬
课程名称数据结构成
绩
实验名称图的存储结构和遍历
1．实验目的
（1）了解邻接矩阵存储法和邻接表存储法的实现过程。
（2）了解图的深度优先遍历和广度优先遍历的实现过程。
2．实验内容
1. 采用图的邻接矩阵存储方法，实现下图的邻接矩阵存储，并输出该矩阵.
2. 设计一个将第1小题中的邻接矩阵转换为邻接表的算法，并设计一个在屏幕上显示邻接表的算法
3. 实现基于第2小题中邻接表的深度优先遍历算法，并输出遍历序列
4. 实现基于第2小题中邻接表的广度优先遍历算法，并输出遍历序列
3．实验环境
Visual C++ 6.0
4．实验方法和步骤（含设计）
我们通过二维数组中的值来表示图中节点与节点的关系。
通过上图可知，其邻接矩阵示意图为如下：
V0 v1 v2 v3 v4 v5
V0 0 1 0 1 0 1
V1 1 0 1 1 1 0
V2 0 1 0 0 1 0
V3 1 1 0 0 1 1
V4 0 1 1 1 0 0
V5 1 0 0 1 0 0
此时的“1”表示这两个节点有关系，“0”表示这两个节点无关系。
我们通过邻接表来在计算机中存储图时，其邻接表存储图如下：
}。
河南工业大学实验报告_实验二 非线性结构(二)——图
河南工业大学实验报告课程名称数据结构实验项目实验二非线性结构(二)——图院系信息学院计科系专业班级计科1401 姓名赵振学号 201416010121 指导老师范艳峰日期 2013.5.17 批改日期成绩一实验目的1．掌握图的邻接矩阵和邻接链表存储结构。
2．掌握图的建立、遍历、最小生成树等典型操作。
二实验内容及要求实验内容：（自选一题）1．建立图的邻接矩阵或邻接链表存储结构，并在对应存储结构上实现图的递归遍历操作。
2．在邻接矩阵存储结构上，完成最小生成树的操作。
实验要求：1. 根据所选题目，用C语言编写程序源代码。
2. 源程序须编译调试成功，独立完成。
三实验过程及运行结果本次试验是采用邻接表的方法建立图，然后进行深度优先遍历具体实现结如下：//算法功能：采用邻接表存储结构建立无向图#include <stdio.h>#include <stdlib.h>#define OK 1#define NULL 0#define MAX_VERTEX_NUM 20 // 最大顶点数typedef int Status; //函数的类型，其值是函数结果状态代码typedef char VertexType;typedef int VRType;typedef int InforType;typedef struct ArcNode{int adjvex; //该边所指的顶点的位置struct ArcNode *nextarc; //指向下一条边的指针int weight; //边的权}ArcNode; //表的结点typedef struct VNode{VertexType data; //顶点信息（如数据等）ArcNode *firstarc; //指向第一条依附该顶点的边的弧指针}VNode, AdjList[MAX_VERTEX_NUM]; //头结点typedef struct ALGraph{AdjList vertices;int vexnum, arcnum; //图的当前顶点数和弧数}ALGraph;//返回顶点v在顶点向量中的位置int LocateVex(ALGraph G, char v){int i;for(i = 0; v != G.vertices[i].data && i < G.vexnum; i++) ;if(i >= G.vexnum)return -1;return i;}//构造邻接链表Status CreateUDN(ALGraph &G){int j;ArcNode *s, *t;printf("输入无向图顶点数: ");scanf("%d", &G.vexnum);printf("输入无向图边数: ");scanf("%d", &G.arcnum);getchar();for(int i = 0; i < G.vexnum; i++){printf("输入第%d个顶点信息:", i+1);scanf("%c", &G.vertices[i].data); //构造顶点向量 G.vertices[i].firstarc = NULL;getchar();}char v1, v2;for(int k = 0; k < G.arcnum; k++){printf("输入第 %d 条边依附的顶点v1: ", k+1);scanf("%c", &v1);getchar();printf("输入第 %d 条边依附的顶点v2: ", k+1);scanf("%c", &v2);getchar();int i = LocateVex(G, v1);int j = LocateVex(G, v2); //确定v1 , v2在G中的位置s = (ArcNode*) malloc (sizeof(ArcNode));t = (ArcNode*) malloc (sizeof(ArcNode));s->adjvex = j; //该边所指向的顶点的位置为js->nextarc = G.vertices[i].firstarc;G.vertices[i].firstarc =s;t->adjvex = i; //该边所指向的顶点的位置为jt->nextarc = G.vertices[j].firstarc;G.vertices[j].firstarc =t;}return OK;}Status PrintAdjList(ALGraph &G){ArcNode *p;printf("%4s%6s%12s\n", "编号", "顶点", "相邻边编号");for(int i = 0; i < G.vexnum; i++){printf("%4d%6c", i, G.vertices[i].data);for(p = G.vertices[i].firstarc; p; p = p->nextarc) printf("%4d", p->adjvex);printf("\n");}return OK;}int main(){ALGraph G;CreateUDN(G);PrintAdjList(G);return 0;}运行结果如下：四调试情况、设计技巧及体会图的邻接表表示不唯一，这是因为在每个顶点对应的单链表中，各边节点的链接次序可以是任意的，取决于建立邻接表的算法以及边的输入次序，另外对于有N个顶点和E条边的无向图，其邻接表有N个顶点节点和2e个边节点。
数据结构实验报告图的存储
数据结构实验报告图的存储数据结构图实验报告一、实验目的和要求（1）掌握图的相关概念，包括图，有向图，无向图，完全图，子图，连通图，度，入度，出度，简单回路和环等定义。
（2）重点掌握图的各种存储结构，包括邻接矩阵和邻接表等。
（3）重点掌握图的基本运算，包括创建图，输出图，深度优先遍历，广度优先遍历等。
（4）掌握图的其他运算，包括最小生成树，最短路径，拓扑排序和关键路径等算法。
（5）灵活运用图这种数据结构解决一些综合应用问题。
二、实验内容和方法(1)实验内容：1、编写一个程序algo8-1.cpp，实现不带权图和带权图的邻接矩阵与邻接表的相互转换算法、输出邻接矩阵与邻接表的算法，并在此基础上设计一个程序exp8-1.cpp实现如下功能：①建立如图1所示的有向图G的邻接矩阵，并输出；②由有向图G的邻接矩阵产生邻接表，并输出；③再由②的邻接表产生对应的邻接矩阵，并输出。
图12、编写一个程序algo8-2.cpp，实现图的遍历运算，并在此基础上设计一个程序exp8-2.cpp完成如下功能：①输出图1所示的有向图G从顶点0开始的深度优先遍历序列（递归算法）；②输出图1所示的有向图G从顶点0开始的深度优先遍历序列（非递归算法）；③输出图1所示的有向图G从顶点0开始的广度优先遍历序列。
3、设计一个程序exp8-3.cpp,采用邻接表存储图，并输出图8.1（a）中从指定顶点1出发的所有深度优先遍历序列。
(2)实验方法：1、综合运用课本所学的知识，用不同的算法实现在不同的程序功能。
2、结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。
3、根据实验内容，编译程序。
三、实验环境：Windows 7，Visual C++6.0三、实验过程描述文件graph.h中定义了图的邻接矩阵表示类型和邻接表表示类型，该头文件在以下三个实验中都会使用到。
其代码如下：#ifndef GRAPH_H_INCLUDED#define GRAPH_H_INCLUDEDtypedef int InfoType;#define MAXV 100 //最大顶点个数#define INF 32767 //INF表示无限大//以下定义邻接矩阵类型typedef struct{int no;InfoType info;}VertexType;typedef struct{int edges[MAXV][MAXV];int n,e;VertexType vexs[MAXV];}MGraph;//以下定义邻接表类型typedef struct ANode{int adjvex;struct ANode* nextarc;InfoType info;}ArcNode;typedef int Vertex;typedef struct VNode{Vertex data;实验①源程序。
图的实验报告
《数据结构》实验报告题目：图一、实现图的邻接矩阵和邻接表存储（一）需求分析对于下图所示的有向图G，编写一个程序完成如下功能：1．建立G的邻接矩阵并输出之2．由G的邻接矩阵产生邻接表并输出之3．再由2的邻接表产生对应的邻接矩阵并输出之（二）系统设计1、本程序中用到的所有抽象数据类型的定义；typedef struct{ int no;InfoType info;} VertexType; //顶点类型typedef struct //图的定义{ int edges[MAXV][MAXV];int vexnum,arcnum;VertexType vexs[MAXV];} MGraph; //图的邻接矩阵类型typedef struct ANode //弧的结点结构类型{ int adjvex;struct ANode *nextarc;InfoType info;} ArcNode;typedef int Vertex;typedef struct Vnode //邻接表头结点的类型{ Vertex data;ArcNode *firstarc; //指向第一条弧} VNode;typedef VNode AdjList[MAXV]; //AdjList是邻接表类型typedef struct{ AdjList adjlist; //邻接表int n,e;} ALGraph; //图的邻接表类型2、主程序的流程以及各程序模块之间的层次调用关系，函数的调用关系图：3、列出各个功能模块的主要功能及输入输出参数void MatToList(MGraph g,ALGraph *&G) 将邻接矩阵g转换成邻接表Gvoid DispMat(MGraph g) 输出邻接矩阵gvoid DispAdj(ALGraph *G) 输出邻接表Gint OutDegree(ALGraph *G,int v) 求图中每个顶点的出度（三）调试分析调试过程中还是出现了一些拼写错误，经检查后都能及时修正。
数据结构实验报告--图
.数据结构实验报告图一、实验目的1、熟悉图的结构和相关算法。
二、实验内容及要求1、编写创建图的算法。
2、编写图的广度优先遍历、深度优先遍历、及求两点的简单路径和最短路径的算法。
三、算法描述1、图的邻接表存储表示：对图的每个顶点建立一个单链表，第i个单链表表示所有依附于第i个点的边（对于有向图表示以该顶点为尾的弧）；链表的每个节点存储两个信息，该弧指向的顶点在图中的位置（adjvex）和指向下一条弧的指针（nextarc）。
每个连表的头结点存储顶点的数据：顶点信息（data）和指向依附于它的弧的链表域。
存储表示如下：typedef struct ArcNode {int adjvex; // 该弧所指向的顶点的位置struct ArcNode *nextarc;// 指向下一条弧的指针// InfoType *info; // 该弧相关信息的指针} ArcNode;typedef struct VNode {char data; // 顶点信息int data2;int sngle;ArcNode *firstarc;// 指向第一条依附该顶点的弧} VNode, AdjList[MAX_NUM];typedef struct {AdjList vertices;int vexnum, arcnum;int kind; // 图的种类标志} ALGraph;2、深度优先搜索：假设初始态是图中所有定点未被访问，从图中的某个顶点v开始，访问此顶点，然后依次从v的未访问的邻接点出发深度优先遍历，直至途中所有和v有相同路径的点都被访问到；若图中仍有点未被访问，则从图中另选一个未被访问的点作为起点重复上述过程，直到图中所有点都被访问到。
为了便于区分途中定点是否被访问过，需要附设一个访问标致数组visited [0..n-1]，将其初值均设为false，一旦某个顶点被访问，将对应的访问标志赋值为true。
2、广度优先搜索：假设初始态是图中所有顶点未被访问，从图中的某个顶点v开始依次访问v的各个未被访问的邻接点，然后分别从这些邻接点出发以此访问他们的邻接点，并使“先被访问的邻接顶点”先于“后被访问的邻接顶点”被访问，直至图中所有已被访问过的顶点的邻接顶点都被访问。
数据结构-邻接表存储及遍历-课程设计-实验报告
数据结构-邻接表存储及遍历-课程设计-实验报告数据结构课程设计设计题目：邻接表存储及遍历学生姓名：专业班级：指导教师：完成时间：目录第一章需求分析 01.1 图 01.2 邻接表的概念 01.3邻接表的表示法 0第二章概要分析 (1)2.1 无向图 (1)2.2 有相图 (1)2.3 无向图 (1)2.4有向图 (1)第三章详细分析 (2)3.1 邻接表的建立 (2)3.2 邻接表的建立过程如下： (2)3.2.1无向图邻接表的建立 (2)3.2.2 有向图邻接表的建立 (3)3.3 邻接表的输出过程如下： (4)3.4 邻接表的遍历 (4)3.4.1 连通图的深度优先搜索遍历 (4)3.4.2 有向图的广度优先搜索遍历 (5)3.5 流程图 (6)3.5.1 主流程图 (6)3.5.2 无向图邻接表的流程图 (6)3.5.3 有向图邻接表的流程图 (10)第四章测试分析 (13)4.1 无向图 (14)4.1.1 主程序main()编写如下： (14)4.1.2 运行步骤 (16)4.2 有向图 (18)第五章心得体会 (20)第六章、参考文献 (20)第一章需求分析1.1 图①若图1.1②若图1.1v2图1.11.2 邻接表的概念对于图1.1中的每个顶点vi，该方法把所有邻接于vi的顶点vj链成一个单链表，这个单链表就称为顶点vi的邻接表。
1.3邻接表的表示法邻接表中每个表结点均有2个域，其一是邻接点域（adjvex），用以存放与vi 相邻接的顶点vj的序号；其二是链域（next），用来将邻接表的所有表结点链在一起。
并且为每个顶点vi的邻接表设置一个具有2个域的表头结点：一个是顶点域（vertex），用来存放顶点vi的信息；另一个是指针域（link），用于存入指向vi 的邻接表中第一个表结点的头指针。
第二章概要分析2.1 无向图无向图邻接表的建立，无向图邻接表的输出，无向图邻接表的深度优先搜索遍历，无向图邻接表的广度优先搜索遍历。
数据结构实验报告 图
数据结构实验报告图一、实验目的本次实验的主要目的是深入理解和掌握图这种数据结构的基本概念、存储结构和相关算法，并通过实际编程实现来提高对图的操作和应用能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容（一）图的存储结构1、邻接矩阵邻接矩阵是用一个二维数组来表示图中顶点之间的关系。
如果顶点i 和顶点 j 之间有边相连，则数组中对应的元素值为 1；否则为 0。
这种存储结构简单直观，适用于顶点数较少且边数较多的稠密图。
2、邻接表邻接表是为图的每个顶点建立一个单链表，链表中存储的是与该顶点相邻的顶点信息。
这种存储结构在存储空间上比较节省，适用于顶点数较多且边数较少的稀疏图。
（二）图的遍历算法1、深度优先遍历（DepthFirst Search，简称 DFS）从图中的某个顶点出发，沿着一条路径尽可能深地访问顶点，直到无法继续前进，然后回溯到上一个未完全访问的顶点，继续进行深度优先搜索。
2、广度优先遍历（BreadthFirst Search，简称 BFS）从图中的某个顶点出发，先访问其所有相邻的顶点，然后再依次访问这些相邻顶点的相邻顶点，以此类推，逐层向外扩展。
（三）图的最短路径算法1、迪杰斯特拉（Dijkstra）算法用于求解单源最短路径问题，即从一个给定的源顶点到图中其他所有顶点的最短路径。
2、弗洛伊德（Floyd）算法用于求解任意两个顶点之间的最短路径。
四、实验步骤（一）邻接矩阵的实现｀｀｀cppinclude ＜iostream>using namespace std;const int MAX_VERTEX_NUM ＝ 100;class Graph ｛private:int vertexNum;int edgeNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;edgeNum ＝ 0;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ 0;｝｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ 1;adjMatrixji ＝ 1;edgeNum+＋；｝｝void printGraph(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛cout ＜＜ adjMatrixij ＜＜＂＂；｝cout ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gprintGraph(）；return 0;｝｀｀｀（二）邻接表的实现｀｀｀cppinclude ＜iostream>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void printGraph(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛cout ＜＜ i ＜＜＂：＂；for （int j ＝ 0; j ＜ adjListisize(）； j+＋）｛cout ＜＜ adjListij ＜＜＂＂；｝cout ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gprintGraph(）；return 0;｝｀｀｀（三）深度优先遍历的实现｀｀｀cppinclude ＜iostream>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100;class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM;bool visitedMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛visitedi ＝ false;｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void DFS(int v) ｛visitedv ＝ true;cout ＜＜ v ＜＜＂＂；for （int i ＝ 0; i ＜ adjListvsize(）； i+＋）｛int u ＝ adjListvi;if （！visitedu) ｛DFS(u)；｝｝｝void DFSTraversal(）｛for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv) ｛DFS(v)；｝｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gDFSTraversal(）；return 0;｝｀｀｀（四）广度优先遍历的实现｀｀｀cppinclude ＜iostream>include ＜queue>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM; bool visitedMAX_VERTEX_NUM; public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛visitedi ＝ false;｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void BFS(int v) ｛queue<int> q;visitedv ＝ true;qpush(v)；while （！qempty(））｛int u ＝ qfront(）；qpop(）；cout ＜＜ u ＜＜＂＂；for （int i ＝ 0; i ＜ adjListusize(）； i+＋）｛int w ＝ adjListui;if （！visitedw) ｛visitedw ＝ true;qpush(w)；｝｝｝｝void BFSTraversal(）｛for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv) ｛BFS(v)；｝｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gBFSTraversal(）；return 0;｝｀｀｀（五）迪杰斯特拉算法的实现｀｀｀cppinclude ＜iostream>include ＜climits>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; const int INFINITY ＝ INT_MAX; class Graph ｛private:int vertexNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;int distanceMAX_VERTEX_NUM;bool visitedMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ INFINITY;｝distancei ＝ INFINITY;visitedi ＝ false;｝｝void addEdge(int i, int j, int weight) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ weight;adjMatrixji ＝ weight;｝｝int minDistance(）｛int min ＝ INFINITY;int minIndex ＝－1;for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv ＆＆ distancev ＜＝ min) ｛min ＝ distancev;minIndex ＝ v;｝｝return minIndex;｝void dijkstra(int src) ｛distancesrc ＝ 0;for （int count ＝ 0; count ＜ vertexNum 1; count+＋）｛int u ＝ minDistance(）；visitedu ＝ true;for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv ＆＆ adjMatrixuv!＝ INFINITY ＆＆ distanceu!＝INFINITY ＆＆ distanceu ＋ adjMatrixuv ＜ distancev) ｛distancev ＝ distanceu ＋ adjMatrixuv;｝｝｝for （int i ＝ 0; i ＜ vertexNum; i+＋）｛cout ＜＜＂源点＂＜＜ src ＜＜＂到顶点＂＜＜ i ＜＜＂的最短距离为: ＂＜＜ distancei ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1, 2)；gaddEdge(0, 2, 4)；gaddEdge(1, 2, 1)；gaddEdge(1, 3, 7)；gaddEdge(2, 3, 3)；gaddEdge(3, 4, 5)；gdijkstra(0)；return 0;｝｀｀｀（六）弗洛伊德算法的实现｀｀｀cppinclude ＜iostream>include ＜climits>using namespace std;const int MAX_VERTEX_NUM ＝ 100; const int INFINITY ＝ INT_MAX; class Graph ｛private:int vertexNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;int distanceMAX_VERTEX_NUMMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ INFINITY;｝｝｝void addEdge(int i, int j, int weight) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ weight;｝｝void floyd(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛distanceij ＝ adjMatrixij;｝｝for （int k ＝ 0; k ＜ vertexNum; k+＋）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛if （distanceik!＝ INFINITY ＆＆ distancekj!＝ INFINITY ＆＆distanceik ＋ distancekj ＜ distanceij) ｛distanceij ＝ distanceik ＋ distancekj;｝｝｝｝for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛if （distanceij ＝＝ INFINITY) ｛cout ＜＜＂顶点＂＜＜ i ＜＜＂到顶点＂＜＜ j ＜＜＂的距离为: 无穷大" ＜＜ endl;｝ else ｛cout ＜＜＂顶点＂＜＜ i ＜＜＂到顶点＂＜＜ j ＜＜＂的距离为: ＂＜＜ distanceij ＜＜ endl;｝｝｝｝｝；int main(）｛Graph g(4)；gaddEdge(0, 1, 5)；gaddEdge(0, 3, 10)；gaddEdge(1, 2, 3)；gaddEdge(2, 3, 1)；gfloyd(）；return 0;｝｀｀｀五、实验结果分析（一）邻接矩阵和邻接表的比较邻接矩阵的优点是可以快速判断两个顶点之间是否有边相连，时间复杂度为O(1)。
数据结构实验 图的邻接表和邻接矩阵操作
p->weight=weight; p->nextarc=G.vertices[vv].firstarc; G.vertices[vv].firstarc=p; strcmp(G.vertices[vv].data,v);
q=(ArcNode *)malloc(sizeof(ArcNode)); q->adjvex=vv; q->weight=weight; q->nextarc=G.vertices[ww].firstarc; G.vertices[ww].firstarc=q; strcmp(G.vertices[ww].data,w);
实验报告 6
课程 数据结构 实验名称 图的建立及遍历
第页
专业
班级_ __ 学号_ ___ 姓名
实验日期： 2010 年 11 月 23 日
评分
一 、实验目的
1．学会用邻接矩阵和邻接表实现图结构和对图的基本操作。 2．掌握对图操作的具体实现； 3. 掌握图的两种遍历算法（深度优先、广度优先）； 4、掌握求图的最小生成树和顶点间最短路径的算法；
int adjvex;//该弧指向的顶点的位置 ArcType weight; struct ArcNode *nextarc;//指向下一条弧指针 //InfoType *info;该弧相关信息的指针 }ArcNode; typedef struct VNode { VertexType data;//顶点信息 ArcNode *firstarc;//指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; GraphKind kind; }ALGraph; ALGraph G; struct MiniSpanTree_Flag { VertexType adjvex; ArcType lowcost; }closedge[MAX_VEX_NUM]; typedef bool PathMatrix[MAX_VEX_NUM][MAX_VEX_NUM];
实验报告：图的存储结构和遍历
武汉东湖学院
实验报告
学院：计算机科学学院专业计算机科学与技术2016年11月18日
姓名付磊学号2015040131042
班级计科一班指导老师吴佳芬
课程名称数据结构成
绩
实验名称图的存储结构和遍历
1．实验目的
（1）了解邻接矩阵存储法和邻接表存储法的实现过程。
（2）了解图的深度优先遍历和广度优先遍历的实现过程。
2．实验内容
1. 采用图的邻接矩阵存储方法，实现下图的邻接矩阵存储，并输出该矩阵.
2. 设计一个将第1小题中的邻接矩阵转换为邻接表的算法，并设计一个在屏幕上显示邻接表的算法
3. 实现基于第2小题中邻接表的深度优先遍历算法，并输出遍历序列
4. 实现基于第2小题中邻接表的广度优先遍历算法，并输出遍历序列
3．实验环境
Visual C++ 6.0
4．实验方法和步骤（含设计）
我们通过二维数组中的值来表示图中节点与节点的关系。
通过上图可知，其邻接矩阵示意图为如下：
V0 v1 v2 v3 v4 v5
V0 0 1 0 1 0 1
V1 1 0 1 1 1 0
V2 0 1 0 0 1 0
V3 1 1 0 0 1 1
V4 0 1 1 1 0 0
V5 1 0 0 1 0 0
此时的“1”表示这两个节点有关系，“0”表示这两个节点无关系。
我们通过邻接表来在计算机中存储图时，其邻接表存储图如下：
}。
图的存储实验报告
图的存储实验报告图的存储实验报告引言在计算机科学领域中，图是一种重要的数据结构，用于描述对象之间的关系。
图的存储方式对于图的遍历、搜索和其他操作有着重要的影响。
本实验旨在探究不同的图存储方式，并比较它们在不同操作下的性能差异。
一、邻接矩阵存储方式邻接矩阵是一种常见的图存储方式，它使用二维数组来表示图中各个顶点之间的关系。
在邻接矩阵中，行和列分别代表图中的顶点，矩阵中的元素表示两个顶点之间的边的关系。
实验中，我们通过一个简单的例子来说明邻接矩阵的存储方式。
假设有一个无向图，其中包含5个顶点和6条边。
我们可以使用一个5x5的矩阵来表示这个图，矩阵中的元素为1表示两个顶点之间存在边，为0表示不存在边。
邻接矩阵的优点是可以快速判断两个顶点之间是否存在边，时间复杂度为O(1)。
然而，邻接矩阵的缺点是当图中的边数较少时，会造成存储空间的浪费。
此外，在图中顶点的增加和删除操作时，需要重新调整矩阵的大小，开销较大。
二、邻接表存储方式邻接表是另一种常见的图存储方式，它使用链表来表示图中各个顶点之间的关系。
在邻接表中，每个顶点都有一个链表，链表中存储了与该顶点相邻的顶点。
实验中，我们同样以一个简单的例子来说明邻接表的存储方式。
假设有一个有向图，其中包含4个顶点和5条边。
我们可以使用一个包含4个链表的数组来表示这个图，数组中的每个元素表示一个顶点，链表中的元素表示与该顶点相邻的顶点。
邻接表的优点是在图中边的数量较少时，可以节省存储空间。
此外，在图中顶点的增加和删除操作时，开销较小。
然而，邻接表的缺点是判断两个顶点之间是否存在边的时间复杂度较高，需要遍历链表，时间复杂度为O(顶点的度数)。
三、性能比较与结论通过实验，我们对比了邻接矩阵和邻接表两种图存储方式在不同操作下的性能差异。
在判断两个顶点之间是否存在边的操作中，邻接矩阵的时间复杂度为O(1)，而邻接表的时间复杂度为O(顶点的度数)。
因此，在此操作下，邻接矩阵的性能更优。
数据结构实验报告图实验
数据结构实验报告图实验文件排版存档编号：[UYTR-OUPT28-KBNTL98-UYNN208]图实验一，邻接矩阵的实现1.实验目的（1）掌握图的逻辑结构（2）掌握图的邻接矩阵的存储结构（3）验证图的邻接矩阵存储及其遍历操作的实现2.实验内容（1）建立无向图的邻接矩阵存储（2）进行深度优先遍历（3）进行广度优先遍历3．设计与编码#ifndef MGraph_H#define MGraph_Hconst int MaxSize = 10;template<class DataType>class MGraph{public:MGraph(DataType a[], int n, int e);~MGraph(){}void DFSTraverse(int v);void BFSTraverse(int v);private:DataType vertex[MaxSize];int arc[MaxSize][MaxSize];int vertexNum, arcNum;};#endif#include<iostream>using namespace std;#include ""extern int visited[MaxSize];template<class DataType>MGraph<DataType>::MGraph(DataType a[], int n, int e) {int i, j, k;vertexNum = n, arcNum = e;for(i = 0; i < vertexNum; i++)vertex[i] = a[i];for(i = 0;i < vertexNum; i++)for(j = 0; j < vertexNum; j++)arc[i][j] = 0;for(k = 0; k < arcNum; k++){cout << "Please enter two vertexs number of edge: ";cin >> i >> j;arc[i][j] = 1;arc[j][i] = 1;}}template<class DataType>void MGraph<DataType>::DFSTraverse(int v){cout << vertex[v];visited[v] = 1;for(int j = 0; j < vertexNum; j++)if(arc[v][j] == 1 && visited[j] == 0)DFSTraverse(j);}template<class DataType>void MGraph<DataType>::BFSTraverse(int v){int Q[MaxSize];int front = -1, rear = -1;cout << vertex[v];visited[v] = 1;Q[++rear] = v;while(front != rear){v = Q[++front];for(int j = 0;j < vertexNum; j++)if(arc[v][j] == 1 && visited[j] == 0){cout << vertex[j];visited[j] = 1;Q[++rear] = j;}}}#include<iostream>using namespace std;#include ""extern int visited[MaxSize];template<class DataType>MGraph<DataType>::MGraph(DataType a[], int n, int e) {int i, j, k;vertexNum = n, arcNum = e;for(i = 0; i < vertexNum; i++)vertex[i] = a[i];for(i = 0;i < vertexNum; i++)for(j = 0; j < vertexNum; j++)arc[i][j] = 0;for(k = 0; k < arcNum; k++){cout << "Please enter two vertexs number of edge: ";cin >> i >> j;arc[i][j] = 1;arc[j][i] = 1;}}template<class DataType>void MGraph<DataType>::DFSTraverse(int v){cout << vertex[v];visited[v] = 1;for(int j = 0; j < vertexNum; j++)if(arc[v][j] == 1 && visited[j] == 0)DFSTraverse(j);}template<class DataType>void MGraph<DataType>::BFSTraverse(int v){int Q[MaxSize];int front = -1, rear = -1;cout << vertex[v];visited[v] = 1;Q[++rear] = v;while(front != rear){v = Q[++front];for(int j = 0;j < vertexNum; j++)if(arc[v][j] == 1 && visited[j] == 0){cout << vertex[j];visited[j] = 1;Q[++rear] = j;}}}4.运行与测试5.总结与心得通过该实验的代码编写与调试，熟悉了邻接矩阵在图结构中的应用，在调试过程中遇到很多的问题，在解决问题过程中也使我的写代码能力得到提升二，邻接表的实现1.实验目的（1）掌握图的逻辑结构（2）掌握图的邻接表存储结构（3）验证图的邻接表存储及其遍历操作的实现2.实验内容（1）建立一个有向图的邻接表存储结构（2）对建立的有向图进行深度优先遍历（3）对建立的有向图进行广度优先遍历3.设计与编码#ifndef ALGraph_H#define ALGraph_Hconst int MaxSize = 10;struct ArcNode{int adjvex;ArcNode * next;};template<class DataType>struct VertexNode{DataType vertex;ArcNode * firstedge;};template<class DataType>class ALGraph{public:ALGraph(DataType a[], int n, int e);~ALGraph();void DFSTraverse(int v);void BFSTraverse(int v);private:VertexNode<DataType> adjlist[MaxSize];int vertexNum, arcNum;};#endif#include<iostream>using namespace std;#include""extern int visited[MaxSize];template<class DataType>ALGraph<DataType>::ALGraph(DataType a[], int n, int e){ArcNode * s;int i, j, k;vertexNum = n; arcNum = e;for(i = 0; i < vertexNum; i++){adjlist[i].vertex = a[i];adjlist[i].firstedge = NULL;}for(k = 0; k < arcNum; k++){cout << "Please enter the edge of the serial number of two vertices: ";cin >> i >> j;s = new ArcNode; s->adjvex = j;s->next = adjlist[i].firstedge;adjlist[i].firstedge = s;}}template<class DataType>ALGraph<DataType>::~ALGraph(){ArcNode * p = NULL;for(int i = 0; i < vertexNum; i++){p = adjlist[i].firstedge;while(p != NULL){adjlist[i].firstedge = p->next;delete p;p = adjlist[i].firstedge;}}}template<class DataType>void ALGraph<DataType>::DFSTraverse(int v) {ArcNode * p = NULL; int j;cout << adjlist[v].vertex;visited[v] = 1;p = adjlist[v].firstedge;while(p != NULL){j = p->adjvex;if(visited[j] == 0) DFSTraverse(j);p = p->next;}}template<class DataType>void ALGraph<DataType>::BFSTraverse(int v){int Q[MaxSize];int front = -1, rear = -1;ArcNode * p = NULL;cout << adjlist[v].vertex; visited[v] = 1; Q[++rear] = v; while(front != rear){v = Q[++front];p = adjlist[v].firstedge;while(p != NULL){int j = p->adjvex;if(visited[j] == 0){cout << adjlist[j].vertex; visited[j] = 1; Q[++rear] = j;}p = p->next;}}}#include<iostream>using namespace std;#include""int visited[MaxSize] = {0};int main(){char ch[] = {'A','B','C','D','E'};int i;ALGraph<char> ALG(ch, 5, 6);for(i = 0; i < MaxSize; i++)visited[i] = 0;cout << "Depth-first traverse sequence is: ";(0);cout << endl;for(i = 0; i < MaxSize; i++)visited[i] = 0;cout << "Breadth-first traverse sequence is: ";(0);cout << endl;return 0;}4.运行与调试5.总结与心得通过该实验，掌握了图的邻接表存储结构。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《图的邻接表存储结构实验报告》1.需解决的的问题利用邻接表存储结果，设计一种图。
2.数据结构的定义typedef struct node{//边表结点int adj;//边表结点数据域struct node *next;}node;typedef struct vnode{//顶点表结点char name[20];node *fnext;}vnode,AList[M];typedef struct{AList List;//邻接表int v,e;//顶点树和边数}*Graph;3.程序的结构图4.函数的功能1）建立无向邻接表Graph Create1( )//建立无向邻接表{Graph G;int i,j,k;node *s;G=malloc(M*sizeof(vnode));printf("输入图的顶点数和边数：");scanf("%d%d",&G->v,&G->e);//读入顶点数和边数for(i=0;i<G->v;i++)//建立顶点表{ printf("请输入图第%d个元素:",i+1);scanf("%s",&G->List[i].name);//读入顶点信息G->List[i].fnext=NULL;//边表置为空表}for(k=0;k<G->e;k++)//建立边表--建立了2倍边的结点{ printf("请输入边的两顶点序号：（从0考试）");scanf("%d%d",&i,&j);//读入边（Vi,Vj）的顶点对序号s=(node *)malloc(sizeof(node));//生成边表结点s->adj=j;s->next=G->List[i].fnext;G->List[i].fnext=s;//将新结点*s插入顶点Vi的边表头部s=(node *)malloc(sizeof(node));s->adj=i;//邻接点序号为is->next=G->List[j].fnext;G->List[j].fnext=s;// 将新结点*s插入顶点Vj的边表头部}return G;}2）建立有向邻接图Graph Create2() //有向邻接图{Graph G;int i,j,k;node *q;G=malloc(M*sizeof(vnode));printf("请输入顶点数和弧数：");scanf("%d%d",&G->v,&G->e);for (i=0;i<G->v;i++) //建立有n个顶点的顶点表{ printf("请输入图第%d个元素：",i+1);scanf("%s",&G->List[i].name); //读入顶点信息G->List[i].fnext=NULL;}for (k=0;k<G->e;k++) //建立边表{ printf("请输入两顶点的序号：（从0开始）");scanf("%d%d",&i,&j);q=(node *)malloc(sizeof(node)); //生成新边表结点sq->adj=j; //邻接点序号为jq->next=G->List[i].fnext;G->List[i].fnext=q;}return G;}3）输出无向图的邻接表void Print1(Graph G)//输出无向图的邻接表{int i;node *p;printf("\n\t\t\t邻接表\n");for(i=0;i<G->v;i++){ p=G->List[i].fnext;printf("\t\t\t%d | %3s",i,G->List[i].name);while(p){printf("->%d",p->adj);p=p->next;}printf("\n");}}4）输出个元素的度数void Du(Graph G)//输出各元素的度数{int i,j;node *p;printf("\n\t\t\t各点度数\n");for(i=0;i<G->v;i++){ p=G->List[i].fnext;printf("\t\t\t顶点%2s的度为：",G->List[i].name);j=0;while(p){ j++;p=p->next;}printf("%d\n",j);}}5）返回图结点在的序号int LocateVex(Graph G,char *u){//初始条件：图G存在，u和G中顶点有相同的特征//操作结果：若G中存在顶点u，则返回该顶点在图中的位置;否则返回-1 int i;for(i=0;i<G->v;++i)if(strcmp(u,G->List[i].name)==0)return i;return -1;}6）返回序号为v的图结点的值char *VertexGet(Graph G,int v){if(v>=G->v||v<0)exit(0);return G->List[v].name;}7）返回图结点v的第一个邻接顶点的序号int FirstAdjVex(Graph G,char *v){//初始条件：图G存在，v是G中的某个顶点//操作结果：返回v中第一个邻接顶点的序号。
若顶点在G中没有邻接顶点//则返回-1node *p;int v1;v1=LocateVex(G,v);p=G->List[v1].fnext;if(p)return p->adj;elsereturn -1;}8）找到图结点v的第二个邻接顶点的序号void NextAdjVex(Graph G,char *v,char *w){//初始条件：图G存在，v是G中某个顶点，w是v得邻接点//操作结果：输出v的（相对于w的）下一个邻接点的序号node *p;int v1,w1;v1=LocateVex(G,v);w1=LocateVex(G,w);p=G->List[v1].fnext;while(p&&p->adj!=w1)p=p->next;if(!p||!p->next)printf("没有第二个邻接点!\n");elseprintf("第二个邻接点序号是：%d\n",p->next->adj);}9）深度优先遍历图void DFS(Graph G,int i,int flag[]){node *p;printf("%2s ",G->List[i].name);flag[i]=1;p=G->List[i].fnext;while(p){if(!flag[p->adj])DFS(G,p->adj,flag);p=p->next;}}void DFSTravel(Graph G)//深度优先遍历{int i;int flag[M];//标志数组for(i=0;i<G->v;i++)flag[i]=0;for(i=0;i<G->v;i++)if(!flag[i])DFS(G,i,flag);}10）广度优先遍历void BFSTravel(Graph G)//广度优先遍历{ Queue Q;node *p;int i,j=0;int flag[M];//标志数组Q=malloc(sizeof(M));InitQueue(Q);for(i=0;i<G->v;i++)flag[i]=0;for(i=0;i<G->v;i++)if(flag[i]==0)//此点未被访问{flag[i]=1;printf("%2s ",G->List[i].name);Enter(Q,i);while(Q->front!=Q->rear){Leave(Q,j);//队头元素出队并置为jp=G->List[j].fnext;while(p!=NULL){ if(flag[p->adj]==0){printf("%2s ",G->List[p->adj].name);flag[p->adj]=1;Enter(Q,p->adj);}//ifp=p->next;}//while}//while}//if}5.输入/输出数据1）选择操作2）选择“1”然后输入“3 3”输入“a”，“b”，“c”输入“0 1”，“1 2”，“2 0”3）选择“2”跟选择“1”类似4）选择“3”5）选择“4”输入“1”6）选择“5”输入“a”7）选择“6”8）选择“7”9）选择“0”退出程序6.总结此次实验要求熟练掌握关于图的各项基本操作，重点在利用邻接表存储图的结构，以及深度、广度优先遍历图的方法。