数据结构——图

学生课程实验报告书

匿名

实验项目：图

实验时间：

实验目的：

（1）掌握图的逻辑结构；

（2）掌握图的邻接表存储结构；

（3）掌握图的邻接表存储结构下遍历算法的实现。

实验内容：

（1）建立一个有向图的邻接表存储结构；

（2）对建立的有向图，进行深度优先遍历；

（3）对建立的有向图，进行广度优先遍历；

算法实现如下：

#include

#include

#define MAX_VEX_NUM 30

typedef char VexType;

typedef struct Node

{

int adjvex;

struct Node *next;

}LinkNode; //表结点

typedef struct VNode

{

VexType vexdata;

LinkNode *first;

}VexNode; //顶点

VexNode adjlist[MAX_VEX_NUM]; typedef struct

{

int vexnum,arcnum; //顶点数和边数

}Graph;

int VISITED[MAX_VEX_NUM];

void CreateGraph(VexNode adjlist[],Graph &g)

{

LinkNode *p;

int i,n,m;

char c;

printf("input vexnum and arcnum:\n");

scanf("%d%d",&g.vexnum,&g.arcnum);

c=getchar(); //接收无效字符'\n' printf("input the vexdata:\n");

for(i=0;i

{

scanf("%c",&adjlist[i].vexdata);

adjlist[i].first=NULL;

}

printf("input the arc:\n");

for(i=0;i

{

scanf("%d%d",&n,&m);

p=(LinkNode *)malloc(sizeof(LinkNode));

p->adjvex=m;

p->next=adjlist[n].first;

adjlist[n].first=p;

}

}

void DFS(VexNode adjlist[],int w)

{

LinkNode *p;

VISITED[w]=1;

printf("%c",adjlist[w].vexdata);

p=adjlist[w].first;

while(p)

{

w=p->adjvex;

if(!VISITED[w])

DFS(adjlist,w);

p=p->next;

}

}

void DFSTraverse(Graph g,VexNode adjlist[])

{

int i;

for(i=0;i

VISITED[i]=0;

for(i=0;i

if(!VISITED[i])

DFS(adjlist,i);

}

void BFSTraverse(Graph g,VexNode adjlist[])

{

VexNode queue[MAX_VEX_NUM];

int rear=0,front=0,i,w;

LinkNode *p;

VexNode q;

for(i=0;i

VISITED[i]=0;

for(i=0;i

if(!VISITED[i])

{

VISITED[i]=1;

printf("%c",adjlist[i].vexdata);

queue[rear]=adjlist[i];

rear=(rear+1)%MAX_VEX_NUM;

while(rear!=front)

{

q=queue[front];

front=(front+1)%MAX_VEX_NUM;

p=q.first;

while(p)

{

w=p->adjvex;

if(!VISITED[w])

{

VISITED[w]=1;

printf("%c",adjlist[w].vexdata);

queue[rear]=adjlist[w];

rear=(rear+1)%MAX_VEX_NUM;

}

p=p->next;

}

}

}

}

int main()

{

Graph g;

CreateGraph(adjlist,g);

printf("DFSTraverse:\n");

DFSTraverse(g,adjlist);

printf("\n");

printf("BFSTraverse:\n");

BFSTraverse(g,adjlist);

printf("\n");

system("pause");

return 0;

}

算法结果如下：

（4）修改遍历算法使遍历结果存储数组

深度遍历：

VexType VEX[MAX_VEX_NUM];

static int j=0;

void DFS(VexNode adjlist[],int w)

{

LinkNode *p;

VISITED[w]=1;

VEX[j++]=adjlist[w].vexdata;

p=adjlist[w].first;

while(p)

{

w=p->adjvex;

if(!VISITED[w])

DFS(adjlist,w);

p=p->next;

}

}

void DFSTraverse(Graph g,VexNode adjlist[]) {

int i;

for(i=0;i

VISITED[i]=0;

for(i=0;i

if(!VISITED[i])

DFS(adjlist,i);

}

广度遍历：

void BFSTraverse(Graph g,VexNode adjlist[]) {

VexNode queue[MAX_VEX_NUM];

int rear=0,front=0,i,w,n=0;

LinkNode *p;

VexNode q;

for(i=0;i

VISITED[i]=0;

for(i=0;i

if(!VISITED[i])

{

VISITED[i]=1;

VEX[n++]=adjlist[i].vexdata;

queue[rear]=adjlist[i];

rear=(rear+1)%MAX_VEX_NUM;

while(rear!=front)

{

q=queue[front];

front=(front+1)%MAX_VEX_NUM;

p=q.first;

while(p)

{

w=p->adjvex;

if(!VISITED[w])

{

VISITED[w]=1;

VEX[n++]=adjlist[w].vexdata;

queue[rear]=adjlist[w];

rear=(rear+1)%MAX_VEX_NUM;

}

p=p->next;

}

}

}

}

实验总结：

对于邻接表存储结构下的算法基本掌握，对图的深度遍历与广度遍历有了更深的理解。指导教师评语：

实验成绩_______________ 指导教师_______________