数据结构课程设计-图的遍历和生成树的求解实现说明书

*******************

实践教学

*******************

兰州理工大学

计算机与通信学院

2012年春季学期

算法与数据结构课程设计

题目：图的遍历和生成树的求解实现

专业班级：计算机科学与技术

姓名：***

学号：1234567

指导教师：****

成绩：

目录

摘要 (3)

前言 (4)

正文 (5)

1.问题描述： (5)

2.采用类C语言定义相关的数据类型 (5)

3．各模块流程图及伪码算法 (6)

4．函数的调用关系图 (8)

5．调试分析 (9)

1.调试中遇到的问题及对问题的解决方法 (9)

2.算法的时间复杂度和空间复杂度 (9)

6.测试结果 (10)

参考文献 (14)

图是一种复杂的非线性数据结构，一个图G（Grah）由两个集合V和E

构成，图存在两种遍历方式，深度优先遍历和广度优先遍历，广度优先遍历基本思路是假设从图中某顶点U出发，在访问了顶点U之后依次访问U的各个未访问的领接点，然后分别从这些领接点出发依次访问他们的领接点，并使先访问的顶点的领接点先于后访问的顶点被访问。直至所有领接点被访问到。深度优先的基本思路是从某个顶点出发，访问此顶点，然后依次从V的未被访问的领接点出发深度优先检索土。直至图中所有顶点都被访问到。PRIM算法—KRUSKAL算法；可以对图形进行最小生成树的求解。

主要问题是：

（1）当给出一个表达式时，如何创建图所表达的树，即相应的逻辑结构和存储结构？

（2）表达式建立好以后，如何求出其遍历？深度优先和广度优先遍历。

（3）计算它的最小生成树？主要是prim算法和kruscal算法两种形式。

很多涉及图的操作的算法都是以图的遍历操作为基础，通过遍历的演示，方便在学习中更好的理解突地遍历的过程。

通过对图的深度优先遍历和广度优先遍历的演示，分别两种遍历的不同与其优缺点。

我们在对一些问题进行求解时，会发现有些问题很难找到规律，或者根本无规律可寻。对于这样的问题，可以利用计算机运算速度快的特点，先搜索查找所有可能出现的情况，再根据题目条件从所有可能的情况中，删除那些不符合条件的解。

在深度优先搜索算法中，是深度越大的结点越先得到扩展。如果在搜索中把算法改为按结点的层次进行搜索，本层的结点没有搜索处理完时，不能对下层结点进行处理，即深度越小的结点越先得到扩展，也就是说先产生的结点先得以扩展处理，这种搜索算法称为广度优先搜索法。很多问题都可以用广度优先搜索进行处理，如翻币问题、最短路径问题等。

在计算机中，有多种方法存储图的信息，由于图的结构复杂，使用广泛，一般应根据实际的应用，选择适合的表示方法。常用的图的存储结构有邻接矩阵、邻接多重表和邻接表。

在实际问题当中，经常遇到这类问题，为新建的某个机构进行选址，道路交通路线，如何走完所有路线，旅游线路等一系列问题都涉及到图的知识。图是一种复杂的非线性数据结构，一个图G（Grah）由两个集合V和E。

构成，图存在两种遍历方式，深度优先遍历和广度优先遍历，广度优先遍历基本思路是假设从图中某顶点U出发，在访问了顶点U之后依次访问U的各个未访问的领接点，然后分别从这些领接点出发依次访问他们的领接点，并使先访问的顶点的领接点先于后访问的顶点被访问。直至所有领接点被访问到。深度优先的基本思路是从某个顶点出发，访问此顶点，然后依次从V的未被访问的领接点出发深度优先检索图。直至图中所有顶点都被访问到。PRIM算法—KRUSKAL算法；可以对图形进行最小生成树的求解。

树型结构是一种非线性结构，它用于描述数据元素之间层次关系，如人类社会的族谱等，树型结构的应用非常广泛，磁盘文件目录结构就是一个典型的例子。

1.问题描述：

图是一种复杂的非线性数据结构，一个图G（Grah）由两个集合V和E

构成，图存在两种遍历方式，深度优先遍历和广度优先遍历，广度优先遍历基本思路是假设从图中某顶点U出发，在访问了顶点U之后依次访问U的各个未访问的领接点，然后分别从这些领接点出发依次访问他们的领接点，并使先访问的顶点的领接点先于后访问的顶点被访问。直至所有领接点被访问到。深度优先的基本思路是从某个顶点出发，访问此顶点，然后依次从V的未被访问的领接点出发深度优先检索土。直至图中所有顶点都被访问到。PRIM算法—KRUSKAL算法；可以对图形进行最小生成树的求解。

2.采用类c语言定义相关的数据类型

#define int_max 10000 //定义邻接矩阵最大值10000为无穷大

#define max 20 //最大顶点个数

typedef struct //开始对邻接表或图进行定义

{

char vexs[20]; //顶点数的名称

AdjMatrix arcs; //邻接矩阵

int vexnum,arcnum //图中顶点数和边数

int creatMGraph_L(MGraph_L &G)//创建图用邻接矩阵表示

int visited[max]; //访问标记

typedef struct arcnode //弧结点

int adjvex; //该弧指向的顶点的位置，即边或弧依赖的顶点序号

char *info; // 该弧信息

char data; //结点信息

基本操作：

int creatadj(algraph &gra,MGraph_L G)//用邻接表存储图

int initqueue(linkqueue &q)//初始化队列

int enqueue(linkqueue &q,int e)//入队

int dequeue(linkqueue &q,int &e)//出队

int queueempty(linkqueue q)//判断队为空

void bfstra(algraph gra)//广度优先遍历

int bfstra_fen(algraph gra)//求连通分量

3．各模块流程图及伪码算法

int prim(int g[][max],int n) //最小生成树PRIM算法

{

int lowcost[max],prevex[max]; //LOWCOST[]存储当前集合U分别到剩余结点的最短路径

//prevex[]存储最短路径在U中的结点

int i,j,k,min;

for(i=2;i<=n;i++) //n个顶点，n-1条边

{

lowcost[i]=g[1][i]; //初始化

prevex[i]=1; //顶点未加入到最小生成树中

}

lowcost[1]=0; //标志顶点1加入U集合

for(i=2;i<=n;i++) //形成n-1条边的生成树

{

min=inf;

k=0;

for(j=2;j<=n;j++) //寻找满足边的一个顶点在U,另一个顶点在V的最小边

if((lowcost[j]

{

min=lowcost[j];

k=j;

}

printf("(%d,%d)%d\t",prevex[k]-1,k-1,min);

lowcost[k]=0; //顶点k加入U

for(j=2;j<=n;j++) //修改由顶点k到其他顶点边的权值

if(g[k][j]

{

lowcost[j]=g[k][j];

prevex[j]=k;

}

printf("\n");

}

return 0;

}

int acrvisited[100];//kruscal弧标记数组

int find(int acrvisited[],int f)

{

while(acrvisited[f]>0)

f=acrvisited[f];

return f;

}

void kruscal_arc(MGraph_L G,algraph gra) {

edg edgs[20];

int i,j,k=0;

for(i=0;i!=G.vexnum;++i)

for(j=i;j!=G.vexnum;++j)

{

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

{

edgs[k].pre=i;

edgs[k].bak=j;

edgs[k].weight=G.arcs[i][j].adj;

++k;

}

}

int x,y,m,n;

int buf,edf;

for(i=0;i!=gra.arcnum;++i)

acrvisited[i]=0;

for(j=0;j!=G.arcnum;++j)

{

m=10000;

for(i=0;i!=G.arcnum;++i)

{

if(edgs[i].weight

{

m=edgs[i].weight;

x=edgs[i].pre;

y=edgs[i].bak;

n=i;

}

}

// cout<

// cout<

buf=find(acrvisited,x);

edf=find(acrvisited,y);

// cout<

edgs[n].weight=10000;

if(buf!=edf)

{

acrvisited[buf]=edf;

cout<<"("<

cout<

}

}

}

4．函数的调用关系图函数调用关系如图4.1所示

图4.1 函数调用关系图

5．调试分析

1.调试中遇到的问题及对问题的解决方法

解决Visual C++ 6.0不正确连接的问题

明明改动了一个文件，却要把整个项目全部重新编译链接一次。刚刚链接好，一运行，又提示重新编译链接一次。

这是因为出现了未来文件(修改时间和创建时间比系统时间晚)的缘故。可以这样处理：找到工程文件夹下的debug目录，将创建和修改时间都比系统时间的文件全部删除，然后再从新“Rebuild All”一次。

2.算法的时间复杂度和空间复杂度

关于时间复杂度的计算是按照运算次数来进行的, 关于空间复杂度的计算是在程序运行过程所要借助的内容空间大小。

即：空间复杂是储存空间的大小和变换等等决定的...

时间复杂是逻辑比较、赋值等基本运算的次数决定的...

prim算法的时间复杂度为O（n 2）,kruskcal算法的时间复杂度为O（eloge）prim的空间复杂度为O（n* prevex）, kruskcal算法的空间复杂度为O（n）

6.测试结果(1）输入图的顶点即弧度个数：

(2)分别写出边的权值：

邻接矩阵和邻接表创建成功，显示出菜单：

菜单选择：输入0，显示邻接矩阵

输出y 进行下一步操作，重新选择菜单，输出1显示邻接表：

输出y 进行下一步操作，重新选择菜单，输出2显示广度优先遍历：

输出y 进行下一步操作，重新选择菜单，输出3显示深度优先遍历：

输出y 进行下一步操作，重新选择菜单，输出4，显示prim算法计算最小生成树：

输出y 进行下一步操作，重新选择菜单，输出5，显示kruscal算法计算最小

生成树：

输出y 进行下一步操作，重新选择菜单，输出6,计算出该图的连通分量：输出n，结束操作，退出运行:

设计总结

在这三周的算法与数据结构课程设计中,我的题目是:图的遍历和生成树的求解实现,这三周课程设计中,通过该题目的设计过程,我加深了对图数据结构及队列的逻辑结构,存储结构及图的深度优先和广度优先遍历过程,Prim算法和Kruscal算法进行最小生成树求解过程的理解,对图数据结构上基本运算的实现有所掌握,对课本中所学的各种数据结构进一步理解和掌握,学会了如何把学到的知识用于解决实际问题,锻炼了自己动手的能力。

一个人要完成所有的工作是非常困难和耗时的。在以后的学习中我会更加注意各个方面的能力的协调发展。在课程设计时遇到了很多的问题，在老师的帮助，和对各种资料的查阅中，将问题解决，培养了我自主动手，独立研究的能力，为今后在学习工作中能更好的发展打下了坚实的基础。

三周的课程设计很短暂，但其间的内容是很充实的，在其中我学习到了很多平时书本中无法学到的东西，积累了经验，锻炼了自己分析问题，解决问题的能力，并学会了如何将所学的各课知识融会，组织，来配合学习，三周中我收益很大，学到很多。

致谢

在本次算法与数据结构的课程设计中，我学到了很多的东西，同时也得到了很多人的帮助和指导。在此我非常的感谢他们，感谢他们这些天对我的帮助、感谢他们对我的悉心指导。

其次，我更要感谢我们的指导老师王旭阳老师。谢谢她这三周以来对我们的悉心指导和帮助。感谢她能在百忙中抽出时间，在机房高温之下还非常认真的为我们做课设指导，在此，我深深的感谢我的指导老师。

最后，我还要感谢我们的学校以及学校领导，感谢他们能够给我们一个这么好的锻炼平台，让我们能够对自己所学的知识充分的利用和学习，让我的个人能力也有所提高。

参考文献

1.严蔚敏，吴伟民，《数据结构（C语言版）》，北京：清华大学出版社，2003

2. 严蔚敏，吴伟民，《数据结构题集（C语言版）》，北京：清华大学出版社，2005

3. 《DATA STRUCTURE WITH C++》，William Ford，William Tcpp，北京：清华大学出版社（影印版），2005

4. 谭浩强，《C语言程序设计》，北京：清华大学出版社，2005

附录原程序(带注释)

#include

#include

#include

using namespace std;

#define int_max 10000

#define inf 9999

#define max 20

//…………………………………………邻接矩阵定义……………………

typedef struct ArcCell

{

int adj;

char *info;

}ArcCell,AdjMatrix[20][20];

typedef struct

{

char vexs[20];

AdjMatrix arcs;

int vexnum,arcnum;

}MGraph_L;

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

int localvex(MGraph_L G,char v)//返回V的位置

{

int i=0;

while(G.vexs[i]!=v)

{

++i;

}

return i;

}

int creatMGraph_L(MGraph_L &G)//创建图用邻接矩阵表示"\n"括号

{

ofstream fout("out.doc",ios::out);

char v1,v2;

int i,j,w;

cout<<"…………创建无向图…………"<>G.vexnum>>G.arcnum;

fout<

for(i=0;i!=G.vexnum;++i)

{

cout<<"输入顶点"<

cin>>G.vexs[i];

fout<

}

for(i=0;i!=G.vexnum;++i)

for(j=0;j!=G.vexnum;++j)

{

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

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

}

for(int k=0;k!=G.arcnum;++k)

{

cout<<"输入一条边依附的顶点和权:(a b 3)不包括\"()\""<

cin>>v1>>v2>>w;//输入一条边依附的两点及权值

fout<

fout<

i=localvex(G,v1);//确定顶点V1和V2在图中的位置

j=localvex(G,v2);

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

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

}

cout<<"图G邻接矩阵创建成功！"<

fout.close();

return G.vexnum;

}

void ljjzprint(MGraph_L G)

{

int i,j;

for(i=0;i!=G.vexnum;++i)

{

for(j=0;j!=G.vexnum;++j)

cout<

cout<

}

}

int visited[max];//访问标记

int we;

typedef struct arcnode//弧结点

{

int adjvex;//该弧指向的顶点的位置

struct arcnode *nextarc;//弧尾相同的下一条弧

char *info;//该弧信息

}arcnode;

typedef struct vnode//邻接链表顶点头接点

{

char data;//结点信息

arcnode *firstarc;//指向第一条依附该结点的弧的指针

}vnode,adjlist;

typedef struct//图的定义

{

adjlist vertices[max];

int vexnum,arcnum;

int kind;

}algraph;

//…………………………………………队列定义……………………typedef struct qnode

{

int data;

struct qnode *next;

}qnode,*queueptr;

typedef struct

{

queueptr front;

queueptr rear;

}linkqueue;

//………………………………………………………………………typedef struct acr

{

int pre;//弧的一结点

int bak;//弧另一结点

int weight;//弧的权

}edg;

int creatadj(algraph &gra,MGraph_L G)//用邻接表存储图

{

int i=0,j=0;

arcnode *arc,*tem,*p;

for(i=0;i!=G.vexnum;++i)

{

gra.vertices[i].data=G.vexs[i];

gra.vertices[i].firstarc=NULL;

}

for(i=0;i!=G.vexnum;++i)

{

for(j=0;j!=G.vexnum;++j)

{

if(gra.vertices[i].firstarc==NULL)

{

if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum)

{

arc=(arcnode *)malloc(sizeof(arcnode));

gra.vertices[i].firstarc=arc;

arc->nextarc=NULL;

p=arc;

++j;

while(G.arcs[i][j].adj!=int_max&&j!=G.vexnum)

{

tem=(arcnode *)malloc(sizeof(arcnode));

tem->adjvex=j;

gra.vertices[i].firstarc=tem;

tem->nextarc=arc;

arc=tem;

++j;

}

--j;

}

}

else

{

if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum)

{

arc=(arcnode *)malloc(sizeof(arcnode));

arc->adjvex=j;

p->nextarc=arc;

arc->nextarc=NULL;

p=arc;

}

}

}

}

gra.vexnum=G.vexnum;

gra.arcnum=G.arcnum;

/*for(i=0;i!=gra.vexnum;++i)

{

arcnode *p;

cout<

p=gra.vertices[i].firstarc;

while(p!=NULL)

{

cout<adjvex;

p=p->nextarc;

}

cout<

}*/

cout<<"图G邻接表创建成功！"<

return 1;

}

void adjprint(algraph gra)

{

int i;

for(i=0;i!=gra.vexnum;++i)

{

arcnode *p;

cout<

p=gra.vertices[i].firstarc;

while(p!=NULL)

{

cout<adjvex;

p=p->nextarc;

}

cout<

}

}

int firstadjvex(algraph gra,vnode v)//返回依附顶点V的第一个点

{

if(v.firstarc!=NULL)

return v.firstarc->adjvex;

}

int nextadjvex(algraph gra,vnode v,int w)//返回依附顶点V的相对于W的下一个顶点{

arcnode *p;

p=v.firstarc;

while(p!=NULL&&p->adjvex!=w)

{

p=p->nextarc;

}

if(p->adjvex==w&&p->nextarc!=NULL)

{

p=p->nextarc;

return p->adjvex;

}

if(p->adjvex==w&&p->nextarc==NULL)

return -10;

}

int initqueue(linkqueue &q)//初始化队列

{

q.rear=(queueptr)malloc(sizeof(qnode));

q.front=q.rear;

if(!q.front)

return 0;

q.front->next=NULL;

return 1;

}

int enqueue(linkqueue &q,int e)//入队

{

queueptr p;

p=(queueptr)malloc(sizeof(qnode));

if(!p)

return 0;

p->data=e;

p->next=NULL;

q.rear->next=p;

q.rear=p;

return 1;

}

int dequeue(linkqueue &q,int &e)//出队

{

queueptr p;

if(q.front==q.rear)

return 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 queueempty(linkqueue q)//判断队为空

{

if(q.front==q.rear)

return 1;

return 0;

}

void bfstra(algraph gra)//广度优先遍历

{

int i,e;

linkqueue q;

for(i=0;i!=gra.vexnum;++i)

for(i=0;i!=gra.vexnum;++i)

if(!visited[i])

{ visited[i]=1;

cout<

enqueue(q,i);

while(!queueempty(q))

{

dequeue(q,e);

// cout<<" "<

for(we=firstadjvex(gra,gra.vertices[e]);we>=0;we=nextadjvex(gra,gra.vertices[e],we)) {

if(!visited[we])

{

visited[we]=1;

cout<

enqueue(q,we);

}

}

}

}

}

int dfs(algraph gra,int i);//声明DFS

int dfstra(algraph gra)

{

int i,j;

for(i=0;i!=gra.vexnum;++i)

{

visited[i]=0;

}

for(j=0;j!=gra.vexnum;++j)

{

if(visited[j]==0)

dfs(gra,j);

}

return 0;

}

int dfs(algraph gra,int i)

{

visited[i]=1;

int we1;

// cout<

cout<

// cout<

for(we=firstadjvex(gra,gra.vertices[i]);we>=0;we=nextadjvex(gra,gra.vertices[i],we)) {

// cout<

we1=we;

// cout<

if(visited[we]==0)

// cout<<

dfs(gra,we);//<

// cout<

we=we1;

// cout<

}

return 12;

}

int bfstra_fen(algraph gra)//求连通分量

{

int i,j;

for(i=0;i!=gra.vexnum;++i)

{

visited[i]=0;

}

for(j=0;j!=gra.vexnum;++j)

{

dfs(gra,j);

cout<

}

}

return 0;

}

typedef struct

{

int adjvex;

int lowcost;

}closedge;

/*int minimum(closedge *p);

int minispantree(MGraph_L G,char u)

{

int k,j,i;

closedge closedge_a[20];

k=localvex(G,u);

// cout<

for(j=0;j!=G.vexnum;++j)

{

if(j!=k)

{

closedge_a[j].adjvex=u;

closedge_a[j].lowcost=G.arcs[k][j].adj;

}

for(i=1;i!=G.vexnum;++i)

{

k=minimum(closedge_a);

cout<

cout<

closedge_a[k].lowcost=0;

for(j=0;j!=G.vexnum;++j)

if(G.arcs[k][j].adj

{

closedge_a[j].adjvex=G.vexs[k];

closedge_a[j].lowcost=G.arcs[k][j].adj;

}

}

}

return 0;

}

int minimum(closedge *p)

{

int s=10000;

for(;p!=NULL;++p)

{

if(s>p->lowcost)

s=p->lowcost;

}

return s;

}*/

int prim(int g[][max],int n) //最小生成树PRIM算法

{

int lowcost[max],prevex[max]; //LOWCOST[]存储当前集合U分别到剩余结点的最短路径//prevex[]存储最短路径在U中的结点

int i,j,k,min;

for(i=2;i<=n;i++) //n个顶点，n-1条边

{

lowcost[i]=g[1][i]; //初始化

prevex[i]=1; //顶点未加入到最小生成树中

}

lowcost[1]=0; //标志顶点1加入U集合

for(i=2;i<=n;i++) //形成n-1条边的生成树