图的抽象数据类型实现Word文件下载.docx

图的抽象数据类型实现Word文件下载.docx

《图的抽象数据类型实现Word文件下载.docx》由会员分享，可在线阅读，更多相关《图的抽象数据类型实现Word文件下载.docx（23页珍藏版）》请在冰豆网上搜索。

在图G中增添新顶点v（不增添与顶点相关的边,留待InsertArc（）去做）

DeleteVex

图G存在,v是G中某个顶点

删除G中顶点v及其相关的弧

InsertArc

图G存在,v和W是G中两个顶点

在G中增添弧<

DeleteArc

图G存在,v和w是G中两个顶点

在G中删除弧<

DFSTraverseM

图G存在

对图进行深度优先遍历

BFSTraverseM

对图进行广度优先遍历

}ADTMGraph

三、存储结构定义

头文件：

#include<

stdio.h>

stdlib.h>

#defineMaxLen10/*最大输入长度*/

#defineFalse0

#defineTrue1

#defineErrorprintf

#defineQueueSize30

#defineNull0

#defineOK1

ypedefstruct

{

charvexs[MaxLen];

intedges[MaxLen][MaxLen];

intn,e;

}MGraph;

/*定义全局变量*/

intvisited[10];

/*辅助队列的定义*/

typedefstruct

intfront;

intrear;

intcount;

intdata[QueueSize];

}CirQueue;

voidInitQueue（CirQueue*Q）

Q->

front=Q->

rear=0;

count=0;

}

intQueueEmpty（CirQueue*Q）

returnQ->

count=QueueSize;

intQueueFull（CirQueue*Q）

count==QueueSize;

voidEnQueue（CirQueue*Q,intx）

if（QueueFull（Q））

Error（"

Queueoverflow"

）;

else

{

Q->

count++;

data[Q->

rear]=x;

rear=（Q->

rear+1）%QueueSize;

}//else

}//EnQueue（CirQueue*Q,intx）

intDeQueue（CirQueue*Q）

inttemp;

if（QueueEmpty（Q））

Queueunderflow"

returnNull;

}//if（QueueEmpty（Q））

else{

temp=Q->

front];

count--;

front=（Q->

front+1）%QueueSize;

returntemp;

}//else

}//DeQueue（CirQueue*Q）

四、程序源代码

voidCreateMGraph（MGraph&

G）

{/*初始条件：

n是图的顶点集，e是图的边集*/

/*操作结果：

按和n的e定义构造图G*/

inti,j,k;

charch1,ch2;

printf（"

\t\t请输入顶点数和边数（输入格式为:

顶点数,边数）:

\n\t\t"

scanf（"

%d,%d"

&

（G.n）,&

（G.e））;

\t\t请输入顶点信息（字符型）每个顶点以回车作为结束:

\n"

for（i=0;

i<

G.n;

i++）

getchar（）;

printf（"

\t\t"

scanf（"

%c"

（G.vexs[i]））;

}//for（i=0;

for（j=0;

j<

j++）

G.edges[i][j]=0;

\t\t请输入每条边对应的两个顶点（输入格式为:

i,j）:

for（k=0;

k<

G.e;

k++）

{

getchar（）;

printf（"

\t\t请输入第%d条边的顶点:

"

k+1）;

scanf（"

%c,%c"

ch1,&

ch2）;

for（i=0;

ch1!

=G.vexs[i];

i++）;

for（j=0;

ch2!

=G.vexs[j];

j++）;

G.edges[i][j]=1;

}//for（k=0;

k++）

}//CreateMGraph（MGraph&

voidDestroyGraph（MGraph&

{/*初始条件:

图G存在*/

/*操作结果:

销毁图G*/

inti,j;

G.vexs[i]=Null;

if（G.edges[i][j]）

{

G.edges[i][j]=Null;

}//if（G.edges[i][j]）

}//for（j=0;

G.n=0;

//顶点数置零

G.e=0;

//弧数置零

\t\t图已销毁！

system（"

pause"

}//DestroyGraph（MGraph&

intGetVex（MGraphG）

{/*初始条件:

返回v的值*/

intv;

\t\t请输入要查找的顶点的序号以回车作为结束:

%d"

v）;

if（v<

0||v>

G.n）

没有该顶点"

else

第%d个顶点的值为:

v）;

G.vexs[v-1]）;

returnG.vexs[v-1];

}//GetVex（MGraphG）

intLocateVex（MGraphG,charv）

{/*初始条件：

图G存在，v和G中顶点有相同特征*/

/*操作结果：

否则返回空*/

\t\t请输入要查找的顶点信息（字符类型）以回车作为结束:

inti;

=G.n;

++i）

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

\t\t该接点在图中是第%d个顶点!

i+1）;

system（"

returni+1;

}//if（v==G.vexs[i]）

\t\t没有与之匹配的顶点!

system（"

}//LocateVex（MGraphG,charv）

intPutVex（MGraph&

G,charv,charu）

对v赋值u*/

\t\t该接点已经找到,它在图中是第%d个顶点!

\t\t请输入要赋给该顶点的值（字符类型）以回车作为结束:

u）;

G.vexs[i]=u;

\t\t已将%c顶点改为%c\n"

v,u）;

returnG.vexs[i];

\t\t查找不到该顶点!

}//PutVex（MGraph&

intFirstAdjVex（MGraphG,charv）

若顶点在G中没有邻接顶点，则返回"

空"

*/

for（j=0;

++j）

if（v==G.vexs[i]&

&

G.edges[i][j]）

{

printf（"

\t\t该顶点在图中是第%d个顶点!

\t\t它的第一个邻接顶点是:

%c\n"

G.vexs[j]）;

system（"

returnG.vexs[j];

}//if（v==G.vexs[i]&

returnNull;

}//FirstAdjVex（MGraphG,charv）

intNextAdjVex（MGraphG,charv,charw）

图G存在，v是G中某个顶点，w是v的邻接顶点*/

若w是v的最后一个邻接点，则返回"

inti,j,k,h=0,m=0;

=G.n&

!

h;

h=i;

}

}

if（!

（v==G.vexs[h]））

\t\t%c在图中不存在!

getchar（）;

\t\t请输入%c的邻接顶点w的信息（字符类型）以回车作为结束:

w）;

m;

if（w==G.vexs[j]）

j+1）;

m=j;

}

（w==G.vexs[m]））

w）;

（G.edges[h][m]））

\t\t%c不是%c的邻接顶点!

w,v）;

for（k=m+1;

G.n&

if（G.edges[h][k]）

\t\t%c（相对%c）的下一个邻接顶点是:

v,w,G.vexs[k]）;

returnG.vexs[k];

}//if（G.edges[h][k]）

}//for（k=m+1;

\t\t%c（相对%c）没有下一个邻接点!

v,w）;

returnNull;

}//NextAdjVex（MGraphG,charv,charw）

voidInsertVex（MGraph&

G,charv）

图G存在,v和图G中顶点有相同特征*/

在图G中增添新顶点v（不增添与顶点相关的边,留待InsertArc（）去做）*/

\t\t请输入要添加顶点的值（字符类型）以回车作为结束：

G.vexs[G.n]=v;

/*构造新顶点向量*/

G.edges[G.n][i]=0;

/*初始化该行邻接矩阵的值*/

G.edges[i][G.n]=0;

/*初始化该列邻接矩阵的值*/

G.n+=1;

/*图G的顶点数加1*/

\t\t添加已完成!

}//voidInsertVex（MGraph&

G,charv）

intDeleteVex（MGraph&

图G存在,v是G中某个顶点*/

/*操作结果:

删除G中顶点v及其相关的弧*/

\t\t请输入要删除的顶点的值（字符类型）以回车作为结束：

inti,j,k,m;

do

for（i=0;

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

{

\t\t%c是图中第%d个顶点\n"

v,i+1）;

for（j=0;

{

if（G.edges[i][j]）G.edges[i][j]=Null;

if（G.edges[j][i]）G.edges[j][i]=Null;

}

for（m=G.n;

m>

j;

m--）

if（NextAdjVex（G,v,m））

{

G.edges[j][m-1]=G.edges[j][m];

G.edges[j][m]=Null;

G.e--;

}

else

{

G.edges[m-1][j-1]=G.edges[m][j];

}

}//for（m=G.n;

for（k=i+1;

=G.n+1;

{

G.vexs[k-1]=G.vexs[k];

//删除顶点v并将后续顶点前移

}

G.n--;

\t\t顶点%c已经删除!

returnOK;

}//if（G.vexs[i]==v）

while（G.vexs[i]==v）;

Error（"

\t\t%c不是图中顶点\n"

return0;

}//intDeleteVex（MGraph&

intInsertArc（MGraph&

G,charv,charw）

图G存在,v和W是G中两个顶点*/

*/

\t\t请依次输入要添加弧的两个顶点（格式i,j）以回车作为结束：

v,&

if（G.vexs[i]==v&

G.vexs[j]==w）

if（!

G.edges[i][j]=1;

G.e++;

printf（"

\t\t弧%c%c已经添加!

system（"

returnG.edges[i][j];

}//if（!

G.edges[i][j]

elseprintf（"

\t\t该弧已经存在!

returnNull;

}//if（G.vexs[i]==v&

G.vexs[j]==w）

}//InsertArc（MGraph&

intDeleteArc（MGraph&

图G存在,v和w是G中两个顶点*/

\t\t请依次输入要删除弧的两个顶点（格式i,j）以回车作为结束：

if（G.edges[i][j]）

G.edges[i][j]=Null;

G.e--;

//弧减一

\t\t弧%c%c已经删除!

returnOK;

}//if（G.edges[i][j]）

\t\t弧%c%c不存在!

return0;

}//DeleteArc（MGraph&

voidDFSM（MGraphG,inti）

intj;

\t\t深度优先遍历结点:

结点%C\n"

G.vexs[i]）;

visited[i]=True;

if（G.edges[i][j]==1&

visited[j]）

DFSM（G,j）;

}//DFSM（MGraph*G,inti）

voidDFSTraverseM（MGraphG）

{/*初始条件：

图G存在*/

对图进行深度优先遍历*/

visited[i]=False;

if（!

visited[i]）

DFSM（G,i）;

}//DFSTraverseM（MGraph*G）

voidBFSM（MGraphG,intk）

CirQueueQ;

InitQueue（&

Q）;

\t\t广度优先遍历结点:

结点%c\n"

G.vexs[k]）;

visited[k]=True;

EnQueue（&

Q,k）;

while（!

QueueEmpty（&

Q））

i=DeQueue（&