图的基本操作文档格式.docx
《图的基本操作文档格式.docx》由会员分享，可在线阅读，更多相关《图的基本操作文档格式.docx（16页珍藏版）》请在冰豆网上搜索。
intK;
//////表示遍历过的节点数
intchoose;
//////主菜单选择变量
intNum,Number;
//////Num表示顶点的个数，number表示的为边的个数
voidBuild_VAdjacencyList（）///////建立并初始化头结点
inti;
for（i=0;
i<
Num;
i++）
{
AdjList[i].data=i+1;
AdjList[i].fistarc=NULL;
}
}
voidBuildAdjacencyList（）///////////建立邻接表，当然，在建立邻接表的同时也建立了此图的图的有向图邻接矩阵以及无向图的邻接矩阵
inta,b,c,i,j;
ArcNode*p,*s;
printf（"
请输入图中顶点的个数：
\n"
）;
scanf（"
%d"
&
Num）;
Build_VAdjacencyList（）;
for（j=0;
j<
j++）
if（i==j）
{
map[i][j]=0;
map2[i][j]=0;
}
else
map[i][j]=MAX;
map2[i][j]=MAX;
请输入图中边的个数：
Number）;
请输入各条边的两个顶点以及边的权值:
Number;
scanf（"
%d%d%d"
a,&
b,&
c）;
if（map2[a-1][b-1]>
c）///////建立此图的有向图的邻接矩阵
{
map2[a-1][b-1]=c;
}
if（map[a-1][b-1]>
c）/////这里的2个if为建立此图的无向图的邻接矩阵
map[a-1][b-1]=c;
if（map[b-1][a-1]>
c）/////
map[b-1][a-1]=c;
p=AdjList[a-1].fistarc;
/////一下是建立邻接表
if（p==NULL）
s=（ArcNode*）malloc（sizeof（ArcNode））;
s->
adjvex=b-1;
weight=c;
nextarc=NULL;
AdjList[a-1].fistarc=s;
else
while（p->
nextarc!
=NULL）
p=p->
nextarc;
p->
nextarc=s;
}
voidShowAdjacencyList（）///////以邻接表的形式输出各顶点所连接的点
if（Num==0）
printf（"
请先建立有向图!
else
inti;
ArcNode*p;
for（i=0;
printf（"
从%d直接可达的点有:
"
i+1）;
p=AdjList[i].fistarc;
while（p!
printf（"
%d、"
p->
adjvex+1）;
voidShowAdjacencyListDegree（）//////////////////以邻接表的形式输出各顶点的度
inti,j,sum;
sum=0;
sum++;
for（j=0;
if（j!
=i）
{
p=AdjList[i].fistarc;
while（p!
{
if（p->
adjvex==i）
sum++;
p=p->
}
}
顶点%d的度为:
%d\n"
i,sum）;
voidTopologicalSortAdjacencyList（）///////邻接表的拓扑排序
memset（topocount,0,sizeof（topocount））;
memset（topoflag,0,sizeof（topoflag））;
inti,sum,k=0;
sum=0;
while（sum<
Num）
for（i=0;
if（topoflag[i]==0）
topoflag[p->
adjvex]=1;
}
topoflag[i]=2;
topocount[sum]=i+1;
sum++;
break;
if（i==Num+1）
此有向图有环!
k=1;
break;
if（topoflag[i]==1）
topoflag[i]=0;
if（k==0）
%d"
topocount[i]）;
voidDFS（ArcNode*s）
ArcNode*p;
while（s!
if（flag[s->
adjvex]==0）
s=s->
flag[s->
adjvex]=0;
num[K]=s->
adjvex;
K++;
p=AdjList[s->
adjvex].fistarc;
DFS（p）;
}
voidDFSAdjacencyList（）///////////////////对邻接表进行深度优先遍历
inti,k;
K=0;
flag[i]=1;
for（k=0;
k<
k++）
if（flag[k]==1）
num[K]=k;
K++;
p=AdjList[k].fistarc;
DFS（p）;
深度优先遍历的顺序为:
num[i]+1）;
voidBFSAdjacencyList（）///////对邻接表进行广度优先遍历
inti,j;
j=0;
memset（count,0,sizeof（count））;
if（flag[i]==1）
flag[i]=0;
num[K]=i;
while（j<
K）
p=AdjList[num[j]].fistarc;
j++;
if（flag[p->
adjvex]==1）
{
num[K]=p->
K++;
flag[p->
}
广度优先遍历的顺序为:
voidAdjacencyListPrim（）///////////////////用Prim算法对邻接矩阵求最小生成树
intmin1,pi,i,j,ans=0;
flag[i]=0;
count[i]=map[0][i];
flag[0]=1;
count[0]=0;
for（i=1;
min1=MAX;
if（flag[j]==0&
&
count[j]<
min1）
min1=count[j];
pi=j;
if（min1==MAX）
图不连通!
return;
flag[pi]=1;
count[j]>
map[pi][j]）
count[j]=map[pi][j];
i++）
ans+=count[i];
}
ans）;
voidAdjacencyListDijkstra（）////////////对邻接矩阵对各顶点到其他顶点的最短距离，在此用的是Dijkstra算法
intmin1,pi,i,j,k;
memset（flag,0,sizeof（flag））;
memset（count,0,sizeof（count））;
count[i]=map2[k][i];
flag[k]=1;
count[k]=0;
for（i=1;
min1=MAX;
for（j=0;
if（flag[j]==0&
min1=count[j];
pi=j;
flag[pi]=1;
count[pi]+map2[pi][j]）
count[j]=count[pi]+map2[pi][j];
map3[k][i]=count[i];
}
if（i==j）
continue;
if（map3[i][j]!
=MAX）
printf（"
顶点%d与顶点%d之间的最短距离为:
i+1,j+1,map3[i][j]）;
else
+∞\n"
i+1,j+1）;
voidShowMenu（）//////////////////////菜单
-----------------------------------------------------\n"
|对图的操作如下:
|\n"
|1.建立有向图;
2.输出该临接表|\n"
|3.输出个顶点的度;
4.进行拓扑排序|\n"
|5.深度优先遍历;
6.广度优先遍历|\n"
|7.无向图最小生成树;
8.有向图求最短路径|\n"
|0.退出|\n"
请选择想要进行的操作:
choose）;
intmain（）///////////////////////////////////主函数
Num=0;
Number=0;
ShowMenu（）;
while
（1）
if（choose==0）
break;
elseif（choose==1）
BuildAdjacencyList（）;
ShowMenu（）;
elseif（choose==2）
ShowAdjacencyList（）;
elseif（choose==3）
ShowAdjacencyListDegree（）;
elseif（choose==4）
TopologicalSortAdjacencyList（）;
elseif（choose==5）
DFSAdjacencyList（）;
elseif（choose==6）
BFSAdjacencyList（）;
elseif（choose==7）
AdjacencyListPrim（）;
elseif（choose==8）
AdjacencyListDijkstra（）;
return0;
升级会员 