石大远程在线考试《数据结构》课程设计建立通信网络参考答案.docx
《石大远程在线考试《数据结构》课程设计建立通信网络参考答案.docx》由会员分享，可在线阅读，更多相关《石大远程在线考试《数据结构》课程设计建立通信网络参考答案.docx（15页珍藏版）》请在冰豆网上搜索。
石大远程在线考试《数据结构》课程设计建立通信网络参考答案
中国石油大学（北京）
远程教育学院
《数据结构》课程设计报告
石大远程在线考试——《数据结构》
建立通信网络
第二题参考答案、尾号3,4,5
1需求分析
在n个城市建设通信网络，只需架设n-1条线路即可。
设计算法，求出如果以最低的经济代价建设这个通信网络。
要求如下：
（1）至少包含10个城市；
（2）城市数n由键盘录入；
（3）城市坐标由随机函数产生小于100的整数；
（4）输出生成树中各条边以及它们的权值；
2概要设计
图的存储：
用邻接矩阵，这样会方便不少。
邻接矩阵是一个二维数组，数组中的元素是边的权（一些数值），数组下标号为结点的标号。
（1）例如二维数组中的一个元素M[5][6]的值为39，则表示结点5、6连接，且其上的权值为39。
（2）用邻接矩阵存储图，对图的读写就简单了。
因为邻接矩阵就是一个二维数组，因此对图的读写就是对二维数组的操作。
只要能弄清楚边的编号，就能把图读入了。
3详细设计
//最短路径
#ifndefMYGRAPH_H_
#defineMYGRAPH_H_
classMyGraph
{
public:
voidreadDirectedGraph（）;
MyGraph（intsize）;//构造函数中设置图的大小，分配空间
voidwriteGraph（）;
voidshortPath（intsource）;//求最短路径
protected:
private:
int**m_graph;//用二维数组保存图
intm_size;//图的大小
};
#endif
//构造函数中设置图的大小，分配空间
MyGraph:
:
MyGraph（intsize）
{
inti,j;
m_size=size;
//给图分配空间
m_graph=newint*[m_size];
for（i=0;i{
m_graph[i]=newint[m_size];
}
for（i=0;i{
for（j=0;j{
m_graph[i][j]=INT_MAX;
}
}
}
4程序测试
5感想与体会
本次实验主要是学习掌握图的存储结构，学会编写求最短路径的算法。
本次实验的算法虽有点复杂，但是多上机练习，完成本次实验也不是难事。
通过这次课程设计，我收获了不少的东西。
我选择的题目是最小生成树，这个问题看这简单，但是做起来有非常大的困难。
平时我们很注重理论学习，但现在看来，实践也是非常重要的，两者缺一不可。
在这期间我遇到了不少的问题，问同学，查资料，虽然过程是辛苦琐碎的，但最后成果出来还是很鼓舞人心的。
#include
#include
#include
#include
#include
usingnamespacestd;
structprimnode
{
public:
charbegvex;
charendvex;
intlowcost;
};
structadknode
{
intdist;//最近距离
charway[50];//顶点数组
intnodenum;//经过的顶点数
};
classMgraph//邻接矩阵储存结构
{
public:
Mgraph（）{}
~Mgraph（）{}
voidCreatMGraph（）;
voidDFS（int）;//用递归实现
voidDFS1（int）;//非递归
voidBFS（int）;
voidprint（）;
voidprim（）;
intmini（）;
intlow（）;//最短距离函数的辅助函数
intLocateVex（char）;
voidkruskal（）;
voidDijkstra（）;
voidFloyd（）;
private:
intnumber;//顶点数目
intarcnum;//边的数目
charvexs[50];
intarcs[50][50];
intvisited[50];//便利时的辅助工具
primnodecloseedge[50];//prim
adknodedist[50];//最短路径
intD[20][20];//floyd算法距离
intP[20][20][20];//floyd算法路径
};
intMgraph:
:
LocateVex（chars）
{
for（inti=0;iif（vexs[i]==s）
returni;
return-1;
}
voidMgraph:
:
print（）
{
cout<<"顶点为：
";
for（intk=0;kcout<cout<for（inti=0;i{
for（intj=0;jcout<cout<}
for（intm=0;mcout<cout<}
voidMgraph:
:
CreatMGraph（）//图的邻接矩阵储存结构
{
charvex1,vex2;
inti,j,k,m;
cout<<"请输入定点数，边数：
"<cin>>number>>arcnum;
cout<<"请输入顶点（字符串类型）：
"<for（i=0;icin>>vexs[i];
for（i=0;ifor（j=0;jarcs[i][j]=1000;
for（k=0;k{
cout<<"请输入边的两个顶点及边的权值：
"<cin>>vex1>>vex2>>m;
i=LocateVex（vex1）;
j=LocateVex（vex2）;
arcs[i][j]=m;
arcs[j][i]=m;
}
}
voidMgraph:
:
DFS（inti=0）//用递归实现
{
intj;
cout<";
visited[i]=1;
for（j=0;j{
if（!
（arcs[i][j]==1000）&&!
visited[j]）
DFS（j）;
}
}
voidMgraph:
:
DFS1（inti=0）//非递归
{
stackst;
st.push（i）;
while（!
st.empty（））
{
intj=st.top（）;
st.pop（）;
cout<";
visited[j]=1;
for（intk=0;k{
if（（!
（arcs[j][k]==1000））&&!
visited[k]）
st.push（k）;
}
}
}
voidMgraph:
:
BFS（inti=0）//广度优先遍历
{
dequede;
de.push_back（i）;
cout<";
visited[i]=1;
while（!
de.empty（））
{
intk=de.front（）;
for（intj=0;j{
if（arcs[k][j]!
=1000&&!
visited[j]）
{
cout<";
visited[j]=1;
de.push_back（j）;
}
}
de.pop_front（）;
}
}
intMgraph:
:
mini（）
{
staticinti;
intmin=0;
for（intj=0;j{
if（!
visited[j]）
{
if（closeedge[min].lowcost>closeedge[j].lowcost）
{
min=j;
}
}
}
i=min;
cout<<"包括边（"<returni;
}
voidMgraph:
:
prim（）
{
charu;
cout<<"请输入起始顶点：
"<cin>>u;
inti=LocateVex（u）;
visited[i]=1;
for（intj=0;j{
closeedge[j].begvex=u;
closeedge[j].endvex=vexs[j];
closeedge[j].lowcost=arcs[i][j];
}
for（intm=1;m{
intn=mini（）;
visited[n]=1;
closeedge[n].lowcost=1000;
for（intp=0;p{
if（!
visited[p]）
{
if（arcs[p][n]{
closeedge[p].lowcost=arcs[p][n];
closeedge[p].begvex=vexs[n];
}
}
}
}
}
voidMgraph:
:
kruskal（）
{
inta,b,k=0;
intmin=1000;
intarcs1[20][20];
for（intm=0;mvisited[m]=m;//每一个顶点属于一颗树
for（inti=0;ifor（intj=0;jarcs1[i][j]=arcs[i][j];
while（k{
min=1000;
for（inti=0;i{
for（intj=0;j{
if（arcs1[i][j]{
a=i;
b=j;
min=arcs1[i][j];
}
}
}
if（visited[a]!
=visited[b]）
{
cout<<"包括边（"<k++;
for（intn=0;n{
if（visited[n]==visited[b]）
visited[n]=visited[a];
}
}
else
arcs1[a][b]=arcs[b][a]=1000;
}
}
voidMgraph:
:
Dijkstra（）
{
cout<<"请输入起始点"<charu;
cin>>u;
inti=LocateVex（u）;
visited[i]=1;
for（intj=0;j{
dist[j].dist=arcs[i][j];
dist[j].nodenum=0;
}
for（j=1;j{
intdistance=1000;
intmin=0;
for（intn=0;n{
if（!
visited[n]）
{
if（distance>dist[n].dist）
{
distance=dist[n].dist;
min=n;
}
}
}
intm=min;
visited[m]=1;
for（n=0;n{
if（!
visited[n]）
{
if（（dist[m].dist+arcs[m][n]）{
dist[n].dist=dist[m].dist+arcs[m][n];
dist[n].nodenum=0;
for（intx=0;x{
dist[n].way[x]=dist[m].way[x];
dist[n].nodenum++;
}
dist[n].way[dist[n].nodenum++]=vexs[m];
}}}}
//输出功能
for（intn=0;n{
if（n!
=i）
{if（dist[n].dist<1000）
{
cout<"<cout<<"经过的顶点为：
"<";
for（intp=0;p{cout<";
}
cout<}
else
cout<}}}
voidMgraph:
:
Floyd（）
{
inti,j,m,n;
for（i=0;ifor（j=0;jfor（m=0;mP[i][j][m]=0;
for（i=0;ifor（j=0;j{
D[i][j]=arcs[i][j];
if（D[i][j]<1000）
{
P[i][j][i]=1;
P[i][j][j]=1;
}}
for（i=0;ifor（j=0;jfor（m=0;m{
if（i==j||j==m||i==m）
continue;
if（D[i][m]+D[m][j]{
D[i][j]=D[i][m]+D[m][j];
for（n=0;n{
P[i][j][n]=P[i][m][n]||P[m][j][n];
}}}
for（i=0;ifor（j=0;j{
if（D[i][j]<1000）
{
cout<"<cout<<"经过的顶点为：
";
for（m=0;m{
if（P[i][j][m]）
{
cout<";
}}
cout<else
if（i!
=j）
cout<}
}
intmain（）
{
Mgraphg;
g.CreatMGraph（）;
g.Floyd（）;
return0;
}
升级会员 