数据结构第三次实验报告概论文档格式.docx

数据结构第三次实验报告概论文档格式.docx

《数据结构第三次实验报告概论文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构第三次实验报告概论文档格式.docx（33页珍藏版）》请在冰豆网上搜索。

2．掌握有关图的操作算法并用高级语言实现。

3．熟练掌握图的两种搜索路径的遍历方法。

4.掌握图的有关应用。

实验过程记录

1、最小生成树

Prim\Kruskal算法

#include<

stdio.h>

stdlib.h>

iostream>

#defineMAX_VERTEX_NUM20

#defineOK1

#defineERROR0

#defineMAX1000

usingnamespacestd;

typedefstructArcell

{

doubleadj;

}Arcell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedefstruct

charvexs[MAX_VERTEX_NUM];

//节点数组

AdjMatrixarcs;

//邻接矩阵

intvexnum,arcnum;

//图的当前节点数和弧数

}MGraph;

typedefstructPnode//用于普利姆算法

charadjvex;

//节点

doublelowcost;

//权值

}Pnode,Closedge[MAX_VERTEX_NUM];

//记录顶点集U到V-U的代价最小的边的辅助数组定义

typedefstructKnode//用于算法中存储一条边及其对应的2个节点

charch1;

//节点1

charch2;

//节点2

doublevalue;

//权值

}Knode,Dgevalue[MAX_VERTEX_NUM];

//-----------------------------------------------------------------------------------

intCreateUDG（MGraph&

G,Dgevalue&

dgevalue）;

intLocateVex（MGraphG,charch）;

intMinimum（MGraphG,Closedgeclosedge）;

voidMiniSpanTree_PRIM（MGraphG,charu）;

voidSortdge（Dgevalue&

dgevalue,MGraphG）;

dgevalue）//构造无向加权图的邻接矩阵

inti,j,k;

cout<

<

"

请输入图中节点个数和边/弧的条数：

;

cin>

>

G.vexnum>

G.arcnum;

请输入节点：

for（i=0;

i<

G.vexnum;

++i）

G.vexs[i];

++i）//初始化数组

{

for（j=0;

j<

++j）

G.arcs[i][j].adj=MAX;

}

请输入一条边依附的定点及边的权值：

endl;

for（k=0;

k<

++k）

cin>

dgevalue[k].ch1>

dgevalue[k].ch2>

dgevalue[k].value;

i=LocateVex（G,dgevalue[k].ch1）;

j=LocateVex（G,dgevalue[k].ch2）;

G.arcs[i][j].adj=dgevalue[k].value;

G.arcs[j][i].adj=G.arcs[i][j].adj;

returnOK;

}

intLocateVex（MGraphG,charch）//确定节点ch在图G.vexs中的位置

inta;

for（inti=0;

i<

i++）

if（G.vexs[i]==ch）

a=i;

returna;

//typedefstructPnode//用于普利姆算法

//{

//charadjvex;

//doublelowcost;

//}Pnode,Closedge[MAX_VERTEX_NUM];

voidMiniSpanTree_PRIM（MGraphG,charu）//普利姆算法求最小生成树

Closedgeclosedge;

k=LocateVex（G,u）;

j<

j++）

if（j!

=k）

closedge[j].adjvex=u;

closedge[j].lowcost=G.arcs[k][j].adj;

closedge[k].lowcost=0;

for（i=1;

k=Minimum（G,closedge）;

（"

closedge[k].adjvex<

"

G.vexs[k]<

closedge[k].lowcost<

）"

++j）

if（G.arcs[k][j].adj<

closedge[j].lowcost）

closedge[j].adjvex=G.vexs[k];

closedge[j].lowcost=G.arcs[k][j].adj;

intMinimum（MGraphG,Closedgeclosedge）//求closedge中权值最小的边，并返回其顶点在vexs中的位置

inti,j;

doublek=1000;

if（closedge[i].lowcost!

=0&

&

closedge[i].lowcost<

k）

k=closedge[i].lowcost;

j=i;

returnj;

voidMiniSpanTree_KRSL（MGraphG,Dgevalue&

dgevalue）//克鲁斯卡尔算法求最小生成树

intp1,p2,i,j;

intbj[MAX_VERTEX_NUM];

//标记数组

i++）//标记数组初始化

bj[i]=i;

Sortdge（dgevalue,G）;

//将所有权值按从小到大排序

p1=bj[LocateVex（G,dgevalue[i].ch1）];

p2=bj[LocateVex（G,dgevalue[i].ch2）];

if（p1!

=p2）

dgevalue[i].ch1<

dgevalue[i].ch2<

dgevalue[i].value<

if（bj[j]==p2）

bj[j]=p1;

dgevalue,MGraphG）//对dgevalue中各元素按权值按从小到大排序

doubletemp;

charch1,ch2;

for（j=i;

if（dgevalue[i].value>

dgevalue[j].value）

temp=dgevalue[i].value;

dgevalue[i].value=dgevalue[j].value;

dgevalue[j].value=temp;

ch1=dgevalue[i].ch1;

dgevalue[i].ch1=dgevalue[j].ch1;

dgevalue[j].ch1=ch1;

ch2=dgevalue[i].ch2;

dgevalue[i].ch2=dgevalue[j].ch2;

dgevalue[j].ch2=ch2;

voidmain（）

MGraphG;

charu;

Dgevaluedgevalue;

CreateUDG（G,dgevalue）;

图的邻接矩阵为：

cout<

G.arcs[i][j].adj<

"

=============普利姆算法===============\n"

请输入起始点：

u;

构成最小代价生成树的边集为：

\n"

MiniSpanTree_PRIM（G,u）;

============克鲁斯科尔算法=============\n"

MiniSpanTree_KRSL（G,dgevalue）;

2、拓扑排序

#include"

stdio.h"

conio.h"

stdlib.h"

#defineSTACK_INIT_SIZE16

#defineSTACKINCREMENT5

typedefintSElemType;

typedefcharVertexType;

SElemType*base;

SElemType*top;

intstacksize;

}SqStack;

//我们依然用邻接表来作图的存储结构

typedefstructArcNode{

intadjvex;

structArcNode