图形数据结构实验doc.docx

图形数据结构实验doc.docx

《图形数据结构实验doc.docx》由会员分享，可在线阅读，更多相关《图形数据结构实验doc.docx（21页珍藏版）》请在冰豆网上搜索。

图形数据结构实验doc

淮海工学院计算机科学系

实验报告书

课程名：

《数据结构》

题目：

图形数据结构实验

班级：

学号：

姓名：

评语：

成绩：

指导教师：

批阅时间：

年月日

图形数据结构实验报告要求

1目的与要求:

1）掌握图的邻接矩阵、邻接表、十字链表、邻接多重链表存储结构表示及其创建算法的c语言实现；

2）掌握图的深度优先搜索遍历算法和图的广度优先搜索遍历算法及C语言实现（预习）；

3）掌握AOV-网普里姆构造最小生成树算法的数据结构和算法实现（待学）；

4）掌握AOE-网关路经的生成算法和实现（待学）；

5）按照实验题目要求独立正确地完成实验内容（提交程序清单及相关实验数据与运行结果）；

6）认真书写实验报告,并按时提交（第12周周一提交）。

2实验内容或题目

题目：

一、图形数据结构实验——图的建立与遍历。

内容：

1）使用邻接矩阵和邻接表储表示分别实现如下给定的图1和或图2所示图的物理存储结构。

2）在1）所建立的图形存储结构上分别实现深度优先搜索遍历和广度优先搜索遍历，并给出遍历结果（序列）。

图1无向图

V1

V2

V4

V5

V3

V7

V6

V8

V1

V2

V4

V5

V3

V7

V6

V8

例2有向图

题目：

二、连通网的最小生成树及其应用实验（暂不做）

内容：

对下图所示通信连通网，按照普里姆算法实现其最小生成树。

通信连通网（权值单位：

百万元）

V1

v6

v5

v4

v3

V22

6

5

1

3

5

6

6

4

2

5

3实验步骤与源程序

邻接矩阵

#include

#include

#defineMAX_VERTEX_NUM8

#defineOK1

#defineFALSE0

#defineError-1

#defineAdjTypeint

#defineOtherInfoint

intvisited[MAX_VERTEX_NUM];

#defineTRUE1

#defineMAXSIZE6

typedefstruct

{

intelement[MAXSIZE];

intfront;

intrear;

}SeqQueue;

typedefenum{DG,DN,UDG,UDN}GraphKind;

typedefcharVertexData;

typedefstructArcNode

{

AdjTypeadj;

OtherInfoinfo;

}ArcNode;

typedefstruct

{

VertexDatavexs[MAX_VERTEX_NUM];

ArcNodearcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

intvernum,arcnum;

GraphKindkind;

}AdjMatrix;

intLocateVertex（AdjMatrix*G,VertexDatav）

{

intj=Error;

intk;

for（k=0;kvernum;k++）

if（G->vexs[k]==v）

{

j=k;

break;

}

return（j）;

}

intCreatUDG（AdjMatrix*G）

{

inti,j,k;

VertexDatav1,v2;

cout<<"输入无向图的顶点数和边数：

"<

cin>>G->vernum;

cin>>G->arcnum;

for（i=0;ivernum;i++）

for（j=0;jvernum;j++）

G->arcs[i][j].adj=0;

cout<<"输入图的顶点：

"<

for（i=0;ivernum;i++）

{

cin>>G->vexs[i];

}

for（k=0;karcnum;k++）

{

cout<<"输入一条边的两顶点:

"<

cin>>v1;

cin>>v2;

i=LocateVertex（G,v1）;

j=LocateVertex（G,v2）;

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

G->arcs[j][i].adj=G->arcs[i][j].adj;

}

return（OK）;

}

voidPrint（AdjMatrix*G）

{

inti,j;

for（i=0;ivernum;i++）

{

for（j=0;jarcnum;j++）

cout<arcs[i][j].adj<<"";

cout<

}

}

voidDepthFirstSearch（AdjMatrix*G,intv0）

{

cout<vexs[v0]<

visited[v0]=OK;

for（intvi=1;vivernum;vi++）

{

if（!

visited[vi]&&G->arcs[v0][vi].adj==1）

DepthFirstSearch（G,vi）;

}

}

voidInitQueue（SeqQueue*Q）

{

Q->front=Q->rear=0;

}

intEmpty（SeqQueue*Q）

{

if（Q->front=Q->rear=0）

return（TRUE）;

else

return（Error）;

}

intEnterQueue（SeqQueue*Q,intx）

{

if（（Q->rear+1）%MAXSIZE==Q->front）

{

cout<<"队已满。

"<

return（FALSE）;

}

Q->element[Q->rear]=x;

Q->rear=（Q->rear+1）%MAXSIZE;

return（TRUE）;

}

intDeleteQueue（SeqQueue*Q,int*x）

{

if（Q->front=Q->rear）

{

cout<<"队空"<

return（FALSE）;

}

*x=Q->element[Q->front];

Q->front=（Q->front+1）%MAXSIZE;

return（*x）;

}

intFirstAdj（AdjMatrix*G,intv）

{

intj,p=-1;

for（j=0;j<=G->vernum;j++）

if（G->arcs[v][j].adj==1）

{

p=j;

break;

}

return（p）;

}

intNextAdj（AdjMatrix*G,intv,intw）

{

intj,p=-1;

for（j=w+1;jvernum;j++）

if（G->arcs[v][j].adj==1）

{

p=j;

break;

}

return（p）;

}

voidBreadthFirstSearch（AdjMatrix*G,intv0）

{

SeqQueue*Q;

Q=（SeqQueue*）malloc（sizeof（SeqQueue））;

InitQueue（Q）;

for（inti=0;ivernum;i++）

visited[i]=FALSE;

cout<vexs[v0]<

visited[v0]=OK;

EnterQueue（Q,v0）;

intv,w;

while（!

Empty（Q））

{

v=DeleteQueue（Q,&v）;

for（w=0;wvernum;w++）

{

if（（G->arcs[v][w].adj!

=0）&&（visited[w]==0））

{

cout<vexs[w]<

visited[w]=1;

EnterQueue（Q,w）;

}

}

}

}

voidmain（）

{

AdjMatrix*G;

G=（AdjMatrix*）malloc（sizeof（AdjMatrix））;

CreatUDG（G）;

Print（G）;

cout<<"打印邻接矩阵"<

cout<<"深度优先搜索：

"<

DepthFirstSearch（G,0）;

cout<<"广度优先搜索：

"<

BreadthFirstSearch（G,0）;

}

邻接表

#include

#include

#include

#include

#defineOK1

#defineERROR-1

#defineTRUE1

#defineFALSE0

#definemaxvernum10

#definemaxsize（maxvernum+1）

#defineinfinity32768

typedefstruct

{

intelement[maxsize];

intfront;

intrear;

}Seqqueue;

intEnterqueue（Seqqueue*q,intx）

{

if（（q->rear+1）%maxsize!

=q->front）

{

q->element[q->rear]=x;

q->rear=（q->rear+1）%maxsize;

return（TRUE）;

}

else

{

return（FALSE）;

}

}

intDeletequeue（Seqqueue*q,int*x）

{

if（q->front==q->rear）

{

return（FALSE）;

}

*x=q->element[q->front];

q->front=（q->front+1）%maxsize;

return（TRUE）;

}

intvisited[maxvernum];

typedefstructArcnode

{

intadjvex;

structArcnode*nextarc;

}Arcnode;

typedefstructvexnode

{

intdata;

Arcnode*firstarc;

}vexnode;

typedefstruct

{

vexnodevexs[maxvernum];

intvexnum,arcnum;

}Adjlist;

intLocate（Adjlist*g,intv）

{

intk;

for（k=0;kvexnum;k++）

{

if（g->vexs[k].data==v）

{

returnk;

}

}

return-1;

}

voidCreate（Adjlist*g）

{

inti,j,k,v1,v2;

cout<<"请输入顶点数和弧数:

"<

cin>>g->vexnum>>g->arcnum;

for（i=0;ivexnum;i++）

{

g->vexs[i].data=i+1;

g->vexs[i].firstarc=NULL;

}

cout<<"打印顶点数据:

"<

for（i=0;ivexnum;i++）

{

cout<<"a"<vexs[i].data<<"";

}

cout<

for（k=0;karcnum;k++）

{

cout<<"请输入第"<

"<

cin>>v1>>v2;

i=Locate（g,v1）;

j=Locate（g,v2）;

if（i>=0&&j>=0）

{

Arcnode*p,*q;

p=（Arcnode*）malloc（sizeof（Arcnode））;

p->adjvex=j;

p->nextarc=NULL;

if（!

g->vexs[i].firstarc）

g->vexs[i].firstarc=p;

else

{

q=g->vexs[i].firstarc;

while（q->nextarc）

{

q=q->nextarc;

}

q->nextarc=p;

}

}

}

cout<<"打印邻接表：

"<

for（i=0;ivexnum;i++）

{

if（g->vexs[i].firstarc）

{

Arcnode*p;

cout<vexs[i].data<<"--->";

p=g->vexs[i].firstarc;

while（p->nextarc）

{

cout<<（p->adjvex）+1<<"--->";

p=p->nextarc;

}

cout<<（p->adjvex）+1<

}

elsecout<vexs[i].data<

}

}

intFirst（Adjlistg,intv）

{

if（g.vexs[v].firstarc）

returng.vexs[v].firstarc->adjvex;

else

return-1;

}

intNext（Adjlistg,intv,intw）

{

intflag=0;

Arcnode*p;

p=g.vexs[v].firstarc;

while（p）

{

if（p->adjvex==w）

{

flag=1;

break;

}

p=p->nextarc;

}

if（flag&&p->nextarc）

returnp->nextarc->adjvex;

else

return-1;

}

voidDFS（Adjlistg,intv0）

{

if（g.vexs[v0].firstarc）

{

Arcnode*p;

cout<

visited[v0]=TRUE;

p=g.vexs[v0].firstarc;

while（p!

=NULL）

{

if（!

visited[p->adjvex]）

{

DFS（g,（p->adjvex））;

}

p=p->nextarc;

}

}

else

{

cout<

visited[v0]=TRUE;

}

}

voidBFS（Adjlistg,intv0）

{

Seqqueue*q;

q=（Seqqueue*）malloc（sizeof（Seqqueue））;

q->rear=q->front=0;

intv;

intw;

for（;v0

{

if（!

visited[v0]）

{

cout<

visited[v0]=TRUE;

Enterqueue（q,v0）;

while（q->rear!

=q->front）

{

Deletequeue（q,&v）;

w=First（g,v）;

while（w!

=-1）

{

if（!

visited[w]）

{

cout<

visited[w]=TRUE;

Enterqueue（q,w）;

}

w=Next（g,v,w）;

}

}

}

}

}

voidmain（）

{

Adjlistg;

Create（&g）;

for（inti=0;i

visited[i]=FALSE;

cout<<"深度优先遍历：

";

for（intv0=0;v0

{

if（!

visited[v0]）

DFS（g,v0）;

}

cout<

for（i=0;i

visited[i]=FALSE;

cout<<"广度优先遍历：

";

for（v0=0;v0

{

if（!

visited[v0]）

BFS（g,v0）;

}

cout<

}

4测试数据与实验结果（可以抓图粘贴）

邻接矩阵

邻接表

5结果分析与实验体会

做这次试验我感觉很吃力，邻接表，邻接矩阵都运用的不是很熟练，在书本上没有找到相应的算法，只能硬着头皮自己想办法，跟同学交流了很久才渐渐有了头绪，一开始做起来还是遇到了很多的困难。

之后在图书馆查阅了很多的资料，找了很多的实例才写出最终的算法，希望老师可以给我们一些算法实例，我们结合书本上的理论知识也许会有更好，更深刻的理解.