数据结构实验图.docx
《数据结构实验图.docx》由会员分享，可在线阅读，更多相关《数据结构实验图.docx（19页珍藏版）》请在冰豆网上搜索。
数据结构实验图
实验报告
课程名称:
数据结构
实验7：
图
一、实验目的
1、掌握图的两种存储方法（数组表示法和邻接表表示法）
2、两种存储方式的相互转化
3、掌握邻接表表示法的基础上实现图的遍历
4、掌握图生成最小生成树的方法
5、掌握图的最短路径算法
二、实验内容
1、在文本文件中按照一定的格式存储图的数据
2、从文件中读入该信息，并且构造两种存储方式
3、输出两种存储方式，并进行转化，看是否得到了正确的结果
4、在邻接表的基础上实现图的遍历操作
5、编写图的最小生成树算法，并进行验证
6、编写最短路径算法，并对输入的图进行验证
三、实验环境
硬件条件：
Intel（R）Core（TM）2DuoCPUE8300@2.83GHZ2.00GB的内存
操作系统:
WindowsXP
开发环境:
VisualStudio2008
四、实验步骤和结果
1、分析题意；
2、按要求编写代码；
3、键入代码，调试运行；
五、实验结果和讨论
输入文本文件：
Inputdata.txt
68
1v0
2v1
3v2
4v3
5v4
6v5
v0v5100
v0v430
v0v210
v1v25
v2v350
v3v510
v4v320
v4v560
输出结果：
附件
代码
#include
#include
typedefintStatus;
#defineERROR-1
#defineOK1
#defineINFINITY10000//INT_MAX
#defineMAX_VERTEX_NUM20
typedefstructArcNode
{
intadjvex;
structArcNode*nextarc;
intvalue;//InfoType*info;
}ArcNode;
typedefstructVNode
{
chardata[20];//VertexTypedata;
ArcNode*firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
typedefstruct
{
AdjListvertices;
intvexnum,arcnum;
intkind;
}ALGraph;
/////////////////////////////////////////////////
typedefstructArcCell
{
intadj;//VRTypeadj;
char*info;//InfoType*info;
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedefstruct
{
charvexs[MAX_VERTEX_NUM][20];//VertextTypevexs[MAX_VERTEX_NUM];
AdjMatrixarcs;
intvexnum,arcnum;
}MGraph;
intLocateVex（MGraphG,charV[]）
{
inti;
for（i=0;iif（strcmp（G.vexs[i],V）==0）
returni;
}
//无向图的邻接矩阵
StatusCreateUDN（MGraph&G）
{
FILE*fp;
inti,j,k,w;
charv1[20],v2[20];
fp=fopen（"Inputdata.txt","r"）;
fscanf（fp,"%d%d",&G.vexnum,&G.arcnum）;
for（i=0;i{
fscanf（fp,"%d%s",&j,&G.vexs[i]）;
}
for（i=0;ifor（j=0;j{
G.arcs[i][j].adj=INFINITY;
G.arcs[i][j].info=NULL;
}
for（k=0;k{
fscanf（fp,"%s%s%d",&v1,&v2,&w）;
i=LocateVex（G,v1）;
j=LocateVex（G,v2）;
G.arcs[i][j].adj=w;
G.arcs[j][i]=G.arcs[i][j];
}
for（i=0;i{
for（j=0;jprintf（"%d",G.arcs[i][j].adj）;
printf（"\n"）;
}
returnOK;
}
//有向图的邻接矩阵
StatusCreateDN（MGraph&G）
{
FILE*fp;
inti,j,k,w;
charv1[20],v2[20];
fp=fopen（"Inputdata.txt","r"）;
fscanf（fp,"%d%d",&G.vexnum,&G.arcnum）;
for（i=0;i{
fscanf（fp,"%d%s",&j,&G.vexs[i]）;
}
for（i=0;ifor（j=0;j{
G.arcs[i][j].adj=INFINITY;
G.arcs[i][j].info=NULL;
}
for（k=0;k{
fscanf（fp,"%s%s%d",&v1,&v2,&w）;
i=LocateVex（G,v1）;
j=LocateVex（G,v2）;
G.arcs[i][j].adj=w;
//G.arcs[j][i]=G.arcs[i][j];
}
for（i=0;i{
for（j=0;jprintf（"%d",G.arcs[i][j].adj）;
printf（"\n"）;
}
returnOK;
}
//////////////////////////////////////////////
intLocate（ALGraphG,charV[]）
{
inti;
for（i=0;iif（strcmp（G.vertices[i].data,V）==0）
returni;
}
//有向图的邻接表
StatusCreateDG（ALGraph&G）
{
FILE*fp;
intvertex,edge,i,j,k,v;
chars1[20],s2[20];
fp=fopen（"Inputdata.txt","r"）;
fscanf（fp,"%d%d",&vertex,&edge）;
G.vexnum=vertex;G.arcnum=edge;
for（i=0;i{
fscanf（fp,"%d%s",&k,G.vertices[i].data）;
G.vertices[i].firstarc=NULL;
}
for（k=0;k{
fscanf（fp,"%s%s%d",s1,s2,&v）;
i=Locate（G,s1）;
j=Locate（G,s2）;
ArcNode*Node=newArcNode;
ArcNode*np;
Node->adjvex=j;/////////
Node->nextarc=NULL;
Node->value=v;
if（G.vertices[i].firstarc==NULL）
G.vertices[i].firstarc=Node;
else
{
np=G.vertices[i].firstarc;
while（np->nextarc!
=NULL）
np=np->nextarc;
np->nextarc=Node;
}
}
for（i=0;i{
printf（"%s:
",G.vertices[i].data）;
ArcNode*np=G.vertices[i].firstarc;
while（np!
=NULL）
{
printf（"%s",G.vertices[np->adjvex].data）;
np=np->nextarc;
}
printf（"\n"）;
}
returnOK;
}
//有向图邻接矩阵转化为邻接表
StatusDNtoDG（MGraphG1,ALGraph&G）
{
intvertex,edge,i,j;
chars1[20],s2[20];
G.vexnum=G1.vexnum;G.arcnum=G1.arcnum;
for（i=0;i{
strcpy（G.vertices[i].data,G1.vexs[i]）;
G.vertices[i].firstarc=NULL;
}
for（i=0;i{
for（j=0;j{
if（G1.arcs[i][j].adj!
=INFINITY）
{
ArcNode*Node=newArcNode;
ArcNode*np;
Node->adjvex=j;/////////
Node->nextarc=NULL;
Node->value=G1.arcs[i][j].adj;
if（G.vertices[i].firstarc==NULL）
G.vertices[i].firstarc=Node;
else
{
np=G.vertices[i].firstarc;
while（np->nextarc!
=NULL）
np=np->nextarc;
np->nextarc=Node;
}
}
}
}
for（i=0;i{
printf（"%s:
",G.vertices[i].data）;
ArcNode*np=G.vertices[i].firstarc;
while（np!
=NULL）
{
printf（"%s",G.vertices[np->adjvex].data）;
np=np->nextarc;
}
printf（"\n"）;
}
returnOK;
}
//有向图的邻接表转化为邻接矩阵
StatusDGtoDN（MGraph&G,ALGraphG1）
{
inti,j,k,w;ArcNode*np;
charv1[20],v2[20];
G.vexnum=G1.vexnum;G.arcnum=G1.arcnum;
for（i=0;istrcpy（G.vexs[i],G1.vertices[i].data）;
for（i=0;ifor（j=0;j{
G.arcs[i][j].adj=INFINITY;
G.arcs[i][j].info=NULL;
}
for（k=0;k{
np=G1.vertices[k].firstarc;
while（np!
=NULL）
{
j=np->adjvex;
G.arcs[k][j].adj=np->value;
np=np->nextarc;
}
}
for（i=0;i{
for（j=0;jprintf（"%d",G.arcs[i][j].adj）;
printf（"\n"）;
}
returnOK;
}
//深度优先遍历
intvisited[MAX_VERTEX_NUM];
voidDFS（ALGraphG,intv）
{
visited[v]=1;
printf（"%s\n",G.vertices[v].data）;
ArcNode*np=G.vertices[v].firstarc;
while（np!
=NULL）
{
if（!
visited[np->adjvex]）
DFS（G,np->adjvex）;
np=np->nextarc;
}
}
voidDFSTraverse（ALGraph&G）
{
intv;
for（v=0;vvisited[v]=0;
for（v=0;vif（!
visited[v]）DFS（G,v）;
}
//广度优先遍历
voidBFSTraverse（ALGraph&G）
{
VNodeQ[20];//辅助队列
inti=0,j=0;//队列的头和尾
intv;
for（v=0;vvisited[v]=0;
for（v=0;v{
if（!
visited[v]）
{
Q[j]=G.vertices[v];j++;
visited[v]=1;
printf（"%s\n",Q[i].data）;
while（i!
=j）//断队列是否为空
{
ArcNode*np=Q[i].firstarc;i++;
while（np!
=NULL）
{
if（!
visited[np->adjvex]）
{
visited[np->adjvex]=1;
printf（"%s\n",G.vertices[np->adjvex].data）;
Q[j]=G.vertices[np->adjvex];
j++;
}
np=np->nextarc;
}
}
}
}
}
structCloseDge{
charadjvex[20];
intlowcost;//VRType
}closedge[MAX_VERTEX_NUM];
//最小生成树
voidMinSpanTree_PRIM（MGraphG,charu[]）
{
inti,j,k;
k=LocateVex（G,u）;
for（j=0;jif（j!
=k）
{
strcpy（closedge[j].adjvex,u）;
closedge[j].lowcost=G.arcs[k][j].adj;
}
closedge[k].lowcost=0;
for（i=1;i{
for（j=0;jif（closedge[j].lowcost!
=0）
{
k=j;break;
}
for（;jif（closedge[j].lowcost=0）
k=j;
printf（"%s,%d\n",closedge[k].adjvex,closedge[k].lowcost）;
closedge[k].lowcost=0;
for（j=0;jif（G.arcs[k][j].adj{
strcpy（closedge[j].adjvex,G.vexs[k]）;
closedge[j].lowcost=G.arcs[k][j].adj;
}
}
}
typedefstruct
{
charNode[20];
intD;
charP[100];
intfinal;
}PathMatrix;
//最短路径
voidShortestPath_DIJ（MGraphG,intv0）
{
PathMatrixP[10];
inti,v,k,min;
for（i=0;i{
strcpy（P[i].Node,G.vexs[i]）;
P[i].final=0;
P[i].D=G.arcs[v0][i].adj;
if（P[i].D!
=10000）
strcpy（P[i].P,G.vexs[v0]）;
elseP[i].P[0]='\0';
}
P[v0].D=0;P[v0].final=1;
for（i=1;i{
min=10000;
for（k=0;kif（!
P[k].final）
if（P[k].D{
v=k;
min=P[k].D;
}
P[v].final=1;
for（k=0;kif（!
P[k].final&&（min+G.arcs[v][k].adj{
P[k].D=min+G.arcs[v][k].adj;
strcpy（P[k].P,P[v].P）;
strcat（P[k].P,G.vexs[v]）;
}
}
for（i=0;iprintf（"%s:
%s\n",P[i].Node,P[i].P）;
}
//主函数
voidmain（）
{
ALGraphG,G0;
MGraphG1,G2;
printf（"无向图邻接矩阵\n"）;CreateUDN（G1）;
printf（"最小生成树\n"）;MinSpanTree_PRIM（G1,"v0"）;
printf（"有向图邻接矩阵\n"）;CreateDN（G2）;
printf（"最短路径\n"）;ShortestPath_DIJ（G2,0）;
printf（"有向图邻接表\n"）;CreateDG（G）;
printf（"深度优先遍历\n"）;DFSTraverse（G）;
printf（"广度优先遍历\n"）;BFSTraverse（G）;
printf（"邻接矩阵转化为邻接表\n"）;DNtoDG（G2,G0）;
printf（"邻接表转化为邻接矩阵\n"）;DGtoDN（G2,G）;
}
升级会员 