图的邻接矩阵存储及遍历

实验五 图的邻接矩阵存储及遍历

一、实验学时 2学时

二、背景知识

1．图的邻接矩阵存储结构

设图G ＝（V ，E ）有 n>=1个顶点，其编号分别为1，2，…，n 。描述图G 的邻接矩阵

为二维数组A[1…n ，1…n]，A 的元素定义为：

A []j i ,＝???，，01否则）属于）或（若（E ,,i j j i v v v v

显然无向图的邻接矩阵一定是对称的。

对于网，其邻接矩阵A 的元素定义为：

A []j i ,＝??

???∞=无邻接边到顶点若顶点若为该边上的权有邻接边，到顶点若顶点j i j i w j i w j i j i 0,,

2.图的遍历

深度优先遍历（DFS ）法：

算法步骤：

1）初始化：

（1）置所有顶点“未访问”标志；

（2）打印起始顶点；

（3）置起始顶点“已访问”标志；

（4）起始顶点进栈。

2）当栈非空时重复做：

（1）取栈顶点；

（2）如栈顶顶点存在被访问过的邻接顶点，则选择一个顶点做：

① 打印该顶点；

② 置顶点为“已访问”标志；

③ 该顶点进栈；

否则，当前栈顶顶点退栈。

3）结束。

广度优先遍历（BFS ）法：

算法步骤：

1) 初始化：

（1）置所有顶点“未访问”标志；

（2）打印起始顶点；

（3）置起始顶点“已访问”标志；

（4）起始顶点入队。

2）当队列非空时重复做：

（1）取队首顶点；

（2）对与队首顶点邻接的所有未被访问的顶点依次做：

① 打印该顶点；

② 置顶点为“已访问”标志；

③ 该顶点入队；

否则，当前队首顶点出队。

3) 结束。

三、目的要求

1．掌握图的基本存储方法；

2．掌握有关图的操作算法并用高级语言实现；

3．熟练掌握图的两种搜索路径的遍历方法。

四、实验内容

编写程序实现下图的邻接矩阵表示及其基础上的深度和广度优先遍历。

五、程序实例

图的邻接矩阵表示法的C语言描述：

#include

#include

#include

#define INFINITY 32767

#define MAX_VERTEX_MUN 20

int visited[20];

typedef struct ArcCell

{

int adj;

char *info;

}ArcCell,AdjMatrix[20][20];

typedef struct

{

char vexs[20];

AdjMatrix arcs;

int vexnum,arcnum;

}MGragh;

typedef struct QNode

{

int data;

struct QNode *next;

}QNode,*QueuePtr;

typedef struct{

QueuePtr front;

QueuePtr rear;

}LinkQueue;

int InitQueue(LinkQueue &Q)

{Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.front)

exit(0);

Q.front->next=NULL;

return 1;

}

int EnQueue(LinkQueue &Q,int e)

{

QueuePtr p;

p=(QueuePtr)malloc(sizeof(QNode));

if(!p)

exit(0);

p->next=NULL;

p->data=e;

Q.rear->next=p;

Q.rear=p;

return 1;

}

int DeQueue(LinkQueue &Q,int e)

{QueuePtr p;

if(Q.front==Q.rear)

exit(0);

p=Q.front->next;

e=p->data;

Q.front->next=p->next;

if(Q.rear==p)

Q.rear=Q.front;

free(p);

return 1;

}

int EmptyQueue(LinkQueue Q)

{

if(Q.front==Q.rear)

return 1;

return 0;

}

int LocateVex(MGragh G,char v)

{ int t;

for(t=0;t

if(v==G.vexs[t])

return t;

return -1;

}

int FirstAdjVex(MGragh G,char v)

{ int i,j;

i=LocateVex(G,v);

if(i==-1)

return 0;

for(j=0;j

if(G.arcs[i][j].adj==1)

return j;

return -1;

}

int NextAdjVex(MGragh G,char v,char w)

{

int j,i1,i2;

i1=LocateVex(G,v);

i2=LocateVex(G,w);

if(i1==-1||i2==-1||i1==i2)

return 0;

for(j=i2+1;j

if(G.arcs[i1][i2].adj==1)

return j;

return -1;

}

int Visit(char v)

{printf("%c",v);

return 1;

}

//构造无向图

int CreateUDG(MGragh &G)

{

int v,e,i,j,t;

char v1,v2;

printf("input the number of the vertices:");

scanf("%d",&v);

if(v<0)

return 0;

G.vexnum=v;

printf("input the number of the arcs:");

scanf("%d",&e);

if(e<0)

return 0;

G.arcnum=e;

for(t=0;t

{

printf("input the vertice %d 's information",t+1);

fflush(stdin);

scanf("%c",&G.vexs[t]);

}

for(i=0;i

for(j=0;j

{

G.arcs[i][j].adj=INFINITY;

G.arcs[i][j].info=NULL;

}

for(t=0;t

{

fflush(stdin);

printf("input v1 and v2 is information :v1-v2");

scanf("%c%*c%c",&v1,&v2);

i=LocateVex(G,v1);

j=LocateVex(G,v2);

if(i==-1||j==-1||i==j)

return 0;

G.arcs[i][j].adj=G.arcs[j][i].adj=1;

}

return 1;

}

int BFSTraverse(MGragh G,int(*Visit)(char v))

{

LinkQueue Q;

int v,w,u;

for(v=0;v

visited[v]=0;

InitQueue(Q);

for(v=0;v

{if(!visited[v])

{visited[v]=1;

Visit(G.vexs[v]);

EnQueue(Q,v);

while(!EmptyQueue(Q)){

DeQueue(Q,v);

w=FirstAdjVex(G,G.vexs[v]);

for(;w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])) if(!visited[w])

{visited[w]=1;

Visit(G.vexs[w]);

EnQueue(Q,w);

}}}}

return 1;

}

void DFS(MGragh G,int v)

{

int w;

visited[v]=1;

Visit(G.vexs[v]);

w=FirstAdjVex(G,G.vexs[v]);

for(;w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])) if(!visited[w])

DFS(G,w);

}

void DFSTraverse(MGragh G)

{int v;

for(v=0;v

visited[v]=0;

for(v=0;v

if(!visited[v])

DFS(G,v);

}

void main()

{

MGragh G;

printf("create the UND G:\n");

if(CreateUDG(G))

{

printf("output the UDG G in DFS order:");

DFSTraverse(G);

printf("\n");

printf("output the UDG G in BFS order:");

BFSTraverse(G,Visit);

printf("\n");

}

}