数据结构作业系统第七章答案Word文档格式.docx
《数据结构作业系统第七章答案Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构作业系统第七章答案Word文档格式.docx（12页珍藏版）》请在冰豆网上搜索。
typedefstructVNode{
VertexTypedata;
ArcNode*firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
typedefstruct{
AdjListvertices;
intvexnum,arcnum;
}ALGraph;
StatusDfsReachable（ALGraphg,inti,intj）
.*/{
intk;
ArcNode*p;
visited[i]=1;
for（p=g.vertices[i].firstarc;
p;
p=p->
nextarc）
{
if（p）
k=p->
adjvex;
if（k==j）return1;
if（visited[k]!
=1）
if（DfsReachable（g,k,j））return1;
}
return0;
7.23?
同7.22题要求。
试基于图的广度优先搜索策略写一算法。
StatusBfsReachable（ALGraphg,inti,intj）;
/*Determinewhetheritexistspathfromvertexito*//*vertexjindigraphgwithBreadth_FirstSearch.*//*Array'
visited'
StatusInitQueue（Queue&
q）;
StatusEnQueue（Queue&
q,inte）;
StatusDeQueue（Queue&
q,int&
e）;
StatusQueueEmpty（Queueq）;
StatusGetFront（Queueq,int&
StatusBfsReachable（ALGraphg,inti,intj）/*Determinewhetheritexistspathfromvertexito*//*vertexjindigraphgwithBreadth_FirstSearch.*//*Array'
.*/{
Queueq;
intk,n;
InitQueue（q）;
EnQueue（q,i）;
while（!
QueueEmpty（q））
DeQueue（q,k）;
visited[k]=1;
for（p=g.vertices[k].firstarc;
n=p->
if（n==j）return1;
if（visited[n]!
=1）EnQueue（q,n）;
7.24?
试利用栈的基本操作编写，按深度优先搜索策略
遍历一个强连通图的非递归形式的算法。
算法中不规定具
体的存储结构，而将图Graph看成是一种抽象的数据类型。
voidTraverse（Graphdig,VertexTypev0,void（*visit）（VertexType））;
/*Travelthedigraph'
dig'
withDepth_FirstSearch.*/
图以及相关类型、函数和辅助变量定义如下：
intLocateVex（Graphg,VertexTypev）;
VertexTypeGetVex（Graphg,inti）;
intFirstAdjVex（Graphg,intv）;
intNextAdjVex（Graphg,intv,intw）;
voidvisit（charv）;
StatusInitStack（SStack&
s）;
StatusPush（SStack&
s,SElemTypex）;
StatusPop（SStack&
s,SElemType&
x）;
StatusStackEmpty（SStacks）;
StatusGetTop（SStacks,SElemType&
voidTraverse（Graphdig,VertexTypev0,void（*visit）（VertexType））{
inti,v,flag;
SStacks;
VertexTypep;
//flag来记录某点还有没有邻接点
InitStack（s）;
if（dig.vexnum&
&
dig.arcnum）
{i=LocateVex（dig,v0）;
visited[i]=TRUE;
visit（v0）;
Push（s,v0）;
StackEmpty（s））
{GetTop（s,p）;
v=LocateVex（dig,p）;
flag=0;
for（i=FirstAdjVex（dig,v）;
i>
=0;
i=NextAdjVex（dig,v,i））
{if（!
visited[i]）{p=GetVex（dig,i）;
flag=1;
break;
}}
if（flag）
{visit（p）;
Push（s,p）;
else{Pop（s,p）;
}
7.27?
采用邻接表存储结构，编写一个判别无向图中任意给定的
两个顶点之间是否存在一条长度为k的简单路径的算法。
StatusSinglePath（ALGraphg,VertexTypesv,VertexTypetv,
intk,char*sp）;
/*Judgewhetheritexistsapathfromsvtotvwithlengthk*//*ingraphg,returnpathusingstringspifexists.*/
图的邻接表以及相关类型、函数和辅助变量定义如下：
typedefcharStrARR[100][MAX_VERTEX_NUM+1];
voidinpath（char*&
path,VertexTypev）;
/*Addvertex'
v'
to'
path'
*/
voiddepath（char*&
/*Removevertex'
from'
StatusSinglePath（ALGraphg,VertexTypesv,VertexTypetv,intk,char*sp）
{inti,j,l;
if（sv==tv&
k==0）
{inpath（sp,tv）;
returnOK;
else
i=LocateVex（g,sv）;
inpath（sp,sv）;
l=p->
if（!
visited[l]）
if（SinglePath（g,g.vertices[l].data,tv,k-1,sp））
depath（sp,g.vertices[l].data）;
visited[i]=0;
7.28?
已知有向图和图中两个顶点u和v，试编写算法求
有向图中从u到v的所有简单路径。
voidAllPath（ALGraphg,VertexTypesv,VertexTypetv,
StrARR&
path,int&
i）;
/*Getallthepathsfromvertexsvtotv,savethem*//*intoArraypathwhichcontainsstringcomponents.*//*Returnthenumberofpathusingi*/
typedefcharStrARR[100][MAX_VERTEX_NUM+1];
typedefcharVertexType;
voidinpath（char*path,VertexTypev）;
*/voiddepath（char*path,VertexTypev）;
voidAllPath2（ALGraphg,VertexTypesv,VertexTypetv,
i,int&
d,VertexTypeA[]）
{intj,k,l,m,n;
j=LocateVex（g,sv）;
visited[j]=1;
A[d++]=sv;
if（sv==tv）
m=0;
for（n=0;
n<
d;
n++）
path[i][m++]=A[n];
i++;
for（p=g.vertices[j].firstarc;
AllPath2（g,g.vertices[l].data,tv,path,i,d,A）;
visited[j]=0;
d--;
i）
/*Getallthepathsfromvertexsvtotv,savethem*//*intoArraypathwhichcontainsstringcomponents.*//*Returnthenumberofpathusingi*/{
intd=0,j,l;
VertexTypeA[MAX_VERTEX_NUM],B[MAX_VERTEX_NUM];
for（l=0;
l<
5;
l++）
strcpy（B,path[l]）;
for（j=0;
j<
strlen（path[l]）;
j++）
depath（path[l],B[j]）;
AllPath2（g,sv,tv,path,i,d,A）;
7.31?
试完成求有向图的强连通分量的算法，并分析算法的时间复杂度。
voidStronglyConnected（OLGraphdig,StrARR&
scc,int&
n）;
/*Getallthestronglyconnectedcomponentsinthedigraphdig,*//*andputtheithintoscc[i]whichisastring.*/
图的十字链表以及相关类型和辅助变量定义如下：
intfinished[MAX_VERTEX_NUM];
typedefcharStrARR[MAX_VERTEX_NUM][MAX_VERTEX_NUM+1];
//记录各强连通分量
typedefstructArcBox{
inttailvex,headvex;
structArcBox*hlink,*tlink;
}ArcBox;
typedefstructVexNode{
ArcBox*firstin,*firstout;
}VexNode;
VexNodexlist[MAX_VERTEX_NUM];
}OLGraph;
intcount;
voidDFS1（OLGraphdig,intv）;
voidDFS2（OLGraphdig,intv,StrARR&
scc,intj,intk）;
n）
/*Getallthestronglyconnectedcomponentsinthedigraphdig,*/
/*andputtheithintoscc[i]whichisastring.*/
inti,k=0,v;
count=0;
for（v=0;
v<
dig.vexnum;
v++）
visited[v]）
DFS1（dig,v）;
visited[v]=0;
for（i=dig.vexnum-1;
i--）
v=finished[i];
DFS2（dig,v,scc,n,k）;
n++;
voidDFS1（OLGraphdig,intv）{
intw;
ArcBox*p;
visited[v]=1;
for（p=dig.xlist[v].firstout;
tlink）
{w=p->
headvex;
visited[w]）
DFS1（dig,w）;
finished[count++]=v;
voidDFS2（OLGraphdig,intv,StrARR&
scc,intj,intk）
scc[j][k++]=dig.xlist[v].data;
for（p=dig.xlist[v].firstin;
hlink）
w=p->
tailvex;
DFS2（dig,w,scc,j,k）;
7.29?
试写一个算法，在以邻接矩阵方式存储的有向图G中求顶点i到顶点j的不含回路的、长度为k的路径数。
intSimplePath（MGraphG,inti,intj,intk）;
/*求有向图G的顶点i到j之间长度为k的简单路径条数*/
图的邻接矩阵存储结构的类型定义如下：
typedefenum{DG,DN,AG,AN}GraphKind;
//有向图,有向网,无向图,无向网
VRTypeadj;
//顶点关系类型。
对无权图，用1（是）或0（否）表示相邻否；
//对带权图，则为权值类型
InfoType*info;
//该弧相关信息的指针（可无）}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
AdjMatrixarcs;
//邻接矩阵
VertexTypevexs[MAX_VERTEX_NUM];
//顶点向量
intvexnum,arcnum;
//图的当前顶点数和弧数
GraphKindkind;
//图的种类标志
}MGraph;
intSimplePath（MGraphG,inti,intj,intk）
/*求有向图G的顶点i到j之间长度为k的简单路径条数*/{
intsum=0,v;
if（G.arcs[i][j].adj&
k==1&
!
visited[j]）
sum=1;
if（k>
1）
{visited[i]=1;
G.vexnum;
if（G.arcs[i][v].adj&
sum+=SimplePath（G,v,j,k-1）;
returnsum;
intSearch（SSTables,KeyTypek）;
/*Indextheelementwhichkeyisk*//*inStaticSearchTables.*//*Return0ifxisnotfound.*/
静态查找表的类型SSTable定义如下：
KeyTypekey;
......//其他数据域
}ElemType;
ElemType*elem;
intlength;
}SSTable;
intSearch（SSTablea,KeyTypek）/*Indextheelementwhichkeyisk*//*inStaticSearchTables.*//*Return0ifxisnotfound.*/{
inti;
for（i=1;
i<
=a.length;
i++）
if（a.elem[i].key==k）returni;
升级会员 