数据结构与算法课程设计报告文档格式.docx
- 文档编号:22024678
- 上传时间:2023-02-02
- 格式:DOCX
- 页数:18
- 大小:105.95KB
数据结构与算法课程设计报告文档格式.docx
《数据结构与算法课程设计报告文档格式.docx》由会员分享,可在线阅读,更多相关《数据结构与算法课程设计报告文档格式.docx(18页珍藏版)》请在冰豆网上搜索。
ADTGraph{
数据对象V:
V是具有相同特性的数据元素的集合,称为顶点集;
数据关系R:
R={VR}
VR={<
v,w>
|v,w∈V且P(v,w),<
表示从v到w的弧,谓词P(v,w)定义了弧<
的意义或信息}
基本操作:
CreateGraph(&
G,V,VR);
StatusCreateGraph(MGraph&
G)
//采用邻接矩阵表示法,构造图G.
//采用邻接表表示法,构造图G
StatusMinSpanTree_Prim(MGraphG,VertexTypeu)
//用普里姆算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边
Status
MinSpanTree_Kruskal(MGraphG,VertexTypeu)
//用克鲁斯卡尔算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边
StatusShortestPath_DIJ(MGraphG,intv0,PathMatrix&
p,ShortPathTable&
D)
//用Dijkstra算法求有向网G的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v]
StatusTopSort(ALGraphG)
//若G中无回路,则输出G的顶点的一个拓扑排序并返回OK,否则返回ERROR
存储结构
typedefstruct//邻接矩阵存储结构
{
intno;
intinfo;
}VertexType;
typedefstruct
intedges[MAXV][MAXV];
intn,e;
VertexTypevexs[MAXV];
}MGraph;
typedefstructANode
//邻接表存储结构
{
intadjvex;
structANode*nextarc;
}ArcNode;
typedefstructVnode
intdata;
intcount;
ArcNode*firstarc;
}VNode;
typedefVNodeAdjList[MAXV];
typedefstruct
AdjListadjlist;
}ALGraph;
typedefstructnode
structnode*next;
}List;
4、详细设计
图的邻接矩阵存储结构算法:
StatusCreateUDN(MGraph&
G){
//采用邻接矩阵表示法,构造无向网G
Scanf(&
G.vexnum,&
G.arcnum,&
IncInfo);
//IncInfo为0则各弧不含其他信息
for(i=0;
i<
G.vexnum;
++i)scanf(&
G.vexs[i]);
//构造顶点向量
++i)
//初始化邻接矩阵
for(j=0;
j<
++j)G.arcs[i][j]={INFINITY,NULL};
//{adj,info}
for(k=0;
k<
G.arcnum;
++k){
//构造邻接矩阵
scanf(&
v1,&
v2,&
w);
//输入一条边依附的顶点及权值
i=LocateVex(G,v1);
j=LocateVex(G,v2);
//确定v1和v2在G中位置
G.arcs[i][j].adj=w;
//弧<
v1,v2>
的对称弧<
v2,v1>
}
ReturnOk;
}//CreateUDN
图的邻接表存储结构算法:
void
CreateALGraPh(ALGraph
*G)
//建立无向图的邻接表表示
int
i,j,k;
EdgeNode
*s;
scanf("
%d%d"
,&
G->
n,&
e);
//读入顶点数和边数
for(i=0;
i<
n;
i++){//建立顶点表
adjlist[i].vertex=getchar();
//读入顶点信息
adjlist[i].firstedge=NULL;
//边表置为空表
}
for(k=0;
k<
e;
k++){//建立边表
i,&
j);
读入边(vi,vj)的顶点对序号
s=(EdgeNode
*)malloc(sizeof(EdgeNode));
//生成边表结点
s->
adjvex=j;
//邻接点序号为j
next=G->
adjlist[i].firstedge;
adjlist[i].firstedge=s;
//将新结点*s插入顶点vi的边表头部
adjvex=i;
//邻接点序号为i
adjlist[j].firstedge;
adjlistk[j].firstedge=s;
//将新结点*s插入顶点vj的边表头部
}//end
for
}CreateALGraph
Prim算法实现:
Publicstaticvoidprim(intn,float[][])
//prim算法
{float[]lowcost=newfloat[n+1];
Int[]closest=newint[n+1];
Boolean[]s=newboolean[n+1];
S[1]=true;
for(inti=2;
=n;
i++){
Lowest[i]=c[1][i];
Closest[i]=1;
S[i]=false;
for(inti=1;
n;
floatmin=Float.MAX_VALUE;
intj=1;
for(intk=2;
k++)
if((lowcost[k]<
min)&
&
(!
s[k])){
min=lowcost[k];
j=k;
System.out.println(j+“,”+closest[j]);
S[j]=true;
if((c[j][k]<
lowcost[k])&
lowcost[k]=c[j][k];
closest[k]=j;
Kruskal算法实现:
PublicstaticBooleanKruskal(intn,inte,EdgeNode[]E,EdgeNode[]t)
MinHeapH=newMinHeap
(1);
H.initialize(E,e);
FastUnionFindU=newFastUnionFind(n);
Intk=0;
While(e>
0&
n-1){
EdgeNodex=(EdgeNode)H.removeMin();
e--;
inta=U.find(x.u);
intb=U.find(x.v);
if(a!
=b){
t[k++]=x;
U.union(a,b);
Return(k==n-1);
Dijkstra算法实现:
PublicstaticvoidDijkstra(intv,float[][]a,float[]dist,int[]prev)
{//单源最短路径问题的Dijkstra算法
Intn=dist.length-1;
If(v<
1||v>
n)return;
Boolean[]s=newBoolean[n+1];
//初始化
dist[i]=a[v][i];
s[i]=false;
if(dist[i]==Float.MAX_VALUE)prev[i]=0;
elseprev[i]=v;
Dist[v]=0;
s[v]=true;
floattemp=Float.MAX_VALUE;
intu=v;
for(intj=1;
j++)
if((!
s[i])&
(dist[i]<
temp)){
u=j;
temp=dist[j];
s[u]=true;
s[j])&
(a[u][j]<
Float.MAX_VALUE)){
floatnewdist=dist[u]+a[u][j];
if(newdist<
dist[j]){
//dist[j]减少
dist[j]=newdist;
prev[j]=u;
图的拓扑排序算法:
voidTopSort(ALGraph*G)
{//若G中无回路,则返回G的一个拓扑排序,且函数值为OK,否则为ERROR
inti,j;
ArcNode*p;
if(k!
=G->
n)
{for(i=0;
i++)
{if(G->
adjlist[i].count==0&
v[i]==0)
{path[k]=i;
k++;
v[i]=1;
p=G->
adjlist[i].firstarc;
while(p!
=NULL)
{j=p->
adjvex;
adjlist[j].count--;
p=p->
nextarc;
TopSort(G);
adjlist[j].count++;
else
{for(i=0;
k;
i++)printf("
%d"
path[i]);
printf("
\n"
);
k--;
v[path[k]]=0;
5、程序设计
#include<
stdio.h>
stdlib.h>
#defineMAXV50
#defineINF32767
typedefintInfoType;
//邻接矩阵存储方法
InfoTypeinfo;
}VertexType;
}MGraph;
//狄克斯特拉算法
voidPpath(intpath[],inti,intv)
intk;
k=path[i];
if(k==v)return;
Ppath(path,k,v);
%d,"
k);
}
voidDispath(intdist[],intpath[],ints[],intn,intv)
inti;
if(i==v)continue;
if(s[i]==1)
从%d到%d的最短路径长度为:
%d\t路径为:
"
v,i,dist[i]);
v);
Ppath(path,i,v);
%d\n"
i);
elseprintf("
从%d到%d不存在路径\n"
v,i);
voidDijkstra(MGraphg,intv)
intdist[MAXV],path[MAXV];
ints[MAXV];
intmindis,i,j,u;
g.n;
dist[i]=g.edges[v][i];
s[i]=0;
if(g.edges[v][i]<
INF)path[i]=v;
elsepath[i]=-1;
s[v]=1;
path[v]=0;
mindis=INF;
if(s[j]==0&
dist[j]<
mindis)
mindis=dist[j];
s[u]=1;
if(s[j]==0)
if(g.edges[u][j]<
INF&
dist[u]+g.edges[u][j]<
dist[j])
dist[j]=dist[u]+g.edges[u][j];
path[j]=u;
Dispath(dist,path,s,g.n,v);
//弗洛伊德算法
voidPpath1(intpath[][MAXV],inti,intj)
k=path[i][j];
if(k==-1)return;
Ppath1(path,i,k);
Ppath1(path,k,j);
voidDispath1(intA[][MAXV],intpath[][MAXV],intn)
if(i==j)continue;
if(A[i][j]==INF)
if(i!
=j)printf("
i,j);
else
i,j,A[i][j]);
Ppath1(path,i,j);
j);
voidFloyd(MGraphg)
intA[MAXV][MAXV],path[MAXV][MAXV];
inti,j,k;
A[i][j]=g.edges[i][j];
path[i][j]=-1;
if(A[i][j]>
A[i][k]+A[k][j])
A[i][j]=A[i][k]+A[k][j];
path[i][j]=k;
Dispath1(A,path,g.n);
//主函数
intmain()
inti,j,n;
MGraphg;
请输入带权有向图的顶点个数:
//6
while(scanf("
%d"
&
n)!
=EOF)
请输入带权有向图的邻接矩阵:
/*
053276773276732767
3276704327673276732767
832767032767327679
327673276750327676
3276732767327675032767
332767327673276710
*/
scanf("
g.edges[i][j]);
g.n=n;
采用狄克斯特拉算法得到的最短路径为:
i++)Dijkstra(g,i);
采用弗洛伊德算法得到的最短路径为:
Floyd(g);
\n请输入带权无向图的顶点个数:
return0;
6、程序运行结果:
7、总结体会
通过本次课程设计,对图的概念有了一个新的认识,在学习离散数学的时候,总觉得图是很抽象的东西,但是在学习了《数据结构》后,我慢慢体会到了其中的奥妙,图能够在计算机中存在,首先要知道它有哪些具体化、数字化的信息,比如说权值、顶点个数等,这也就说明了想要把生活中的信息转化到计算机中必须用数字来完整的构成一个信息库,而图的存在,又涉及到了到顶点之间的联系。
赞同
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 算法 课程设计 报告