数据结构图的遍历实验报告doc

数据结构图的遍历实验报告篇一：【数据结构】图的存储和遍历实验报告

《数据结构B》实验报告

系计算机与电子专业级班姓名学号XX年1 0 月9日

1. 上机题目：图的存储和遍历

2. 详细设计

#include

#define GRAPHMAX 10

#define FALSE 0

#define TRUE 1

#define error printf

#define QueueSize 30

typedef struct

{

char vexs[GRAPHMAX];

int edges[GRAPHMAX][GRAPHMAX];

int n,e;

}MGraph;

int visited[10];

typedef struct

{

int front,rear,count;

int data[QueueSize];

}CirQueue;

void InitQueue(CirQueue *Q) {

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

Q->count=0;

}

int QueueEmpty(CirQueue *Q)

{

return Q->count=QueueSize;

}

int QueueFull(CirQueue *Q)

{

return Q->count==QueueSize;

}

void EnQueue(CirQueue *Q,int x) { if(QueueFull(Q)) error("Queue overflow");

文档来源为:从网络收集整理.word 版本可编辑.欢迎下载支

持else

{ Q->count++;

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

Q->rear=(Q->rear+1)%QueueSize;

}

}

int DeQueue(CirQueue *Q)

{

int temp;

if(QueueEmpty(Q))

{ error("Queue underflow");

return NULL;

}

else

{ temp=Q->data[Q->front]; Q->count--;

Q->front=(Q->front+1)%QueueSize;

return temp;

}

}

void CreateMGraph(MGraph *G)

{

int i,j,k;

char ch1,ch2;

printf("\n\t\t 请输入定点数，边数并按回车 (格式如：3，4)：");

scanf("%d,%d", &(G->n),&(G->e));

for(i=0;in;i++)

{ getchar();

printf("\n\t\t 请输入第%d个定点数并按回车：",i+1);

scanf("%c",&(G->vexs[i]));

}

for(i=0;in;i++)

for(j=0;jn;j++)

G->edges[i][j]=0;

for(k=0;ke;k++)

{ getchar();

printf("\n\t\t 请输入第%d条边的顶点序号 (格式如：i,j )：",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;

} }

void DFSM(MGraph *G,int i)

{

int j;

printf("\n\t\t 深 度 优 列： %c\n",G->vexs[i]); visited[i]=TRUE; for(j=0;jn;j++)

if(G->edges[i][j]==1 &&

////////////////

DFSM(G,j);

}

void BFSM(MGraph *G,int k)

{ int i,j; CirQueue Q; InitQueue(&Q);

printf("\n\t\t 广 度 优

列： %c\n",G->vexs[k]);

visited[k]=TRUE;

EnQueue(&Q,k); while(!QueueEmpty(&Q))

{ i=DeQueue(&Q);

先遍历序

visited[j]!=1)

先遍历序

for(j=0;jn;j++)

if(G->edges[i][j]==1 && visited[j]!=1) { visited[j]=TRUE;

EnQueue(&Q,j);

}

}

}

void DFSTraverseM(MGraph *G) {

int i;

for(i=0;in;i++)

visited[i]=FALSE;

for(i=0;in;i++)

if(!visited[i]) DFSM(G,i);

}

void BFSTraverseM(MGraph *G) {

int i;

for(i=0;in;i++) visited[i]=FALSE;

for(i=0;in;i++)

if(!visited[i]) BFSM(G,i);

}

void main()

{

MGraph *G,a;

char ch1;

int i,j,ch2;

G=&a;

printf("\n\t\t 建立一个有向图的邻接矩阵表示\n"); CreateMGraph(G);

printf("\n\t\t 已建立一个有向图的邻接矩阵存储\n"); for(i=0;in;i++)

{ printf("\n\t\t");

for(j=0;jn;j++)

printf("%5d",G->edges[i][j]);

}

getchar();

ch1='y';

while(ch1=='y'||ch1=='Y')

{ printf("\n");

printf("\n\t\t 图的存储与遍历");

("\n\t\t** ******************************");

printf("\n\t\t*1 ---- 更新邻接矩阵*"); printf("\n\t\t*2 ---- 深度优先遍历*"); printf("\n\t\t*3 ---- 广度优先遍历*"); printf("\n\t\t*0 ---- 退出*");

printf("\n\t\t** ******************************");

}

} printf("\n\t\t 请选择菜单号 ( 0 ---------------- 3) "); scanf("%d",&ch2); getchar(); switch(ch2) { case

1:CreateMGraph(G); printf("\n\t\t 图的邻接矩阵存储建立完成

\n");break; case 2:DFSTraverseM(G);break; case

3:BFSTraverseM(G);break; case 0:ch1='n';break;

default:printf("\n\t\t 输出错误！清重新输入！"); }

3. 调试分析

（1）调试过程中主要遇到哪些问题？是如何解决的？由于实习之初对邻接表的存储结构了解不是很清楚，所以在运行出了一个小错误，即在输出邻接表时，每个结点都少了一个邻接点。通过仔细分析，发现是输出邻接表的语句不对，其中的for （）循环语句中的控制条件：p->next!=NULL 出了问题。将其改成

p!=NULL 后，邻接表便可顺利输出。下面就是经修改后以有向图G1和无向图G2为例的程序运行结果

（2）经验和体会：必须培养严谨的科学态度。自己在编程时经常因为一些类似于“少了分号”的小错误而导致错误，不够认真细致，这给自己带来了许多麻烦。编程是一件十分严谨的事情，容不得马虎。所以在今后自己一定要培养严谨的科学态度。我想这不仅是对于程序设计，做任何事都应如此。

4. 测试结果

采用测试数据，列出实际的输入、输出结果。篇二：数据结构实

验- 图的遍历和最小生成树

实验名称：图的遍历和最小生成树

实验内容：

给定无向带权图G 如下，

1. 请分别用深度优先和广度优先两种方法从结点v1 开始对G进行遍历。

2. 构造G 的最小生成树。编程完成上述功能。

要求：

1. 必须完成图的存储功能。图的输入可由命令行完成。

2. 按遍历到的先后顺序依次输出G中各结点内容。

3. 以文本形式输出生成树中各条边以及它们的权值。

一、概要设计图的存储使用数组表示法，即邻接矩阵存储，结构体包含图的邻接矩阵，当前顶点数和弧数。图的初始化使用二重循环得到顶点和表的权值，邻接矩阵的打印使用二重for 循环。然后把图各边的权值按从小到大排序；然后依次把最小边加入进来，即生成最小生成树。克鲁斯卡尔算法：假设WN=(V,{E}) 是一个含有n 个顶点的连通网，按照构造最小生成树的过程为：先构造一个只含n 个顶点，而边集为空的子图，之后，从网的边集E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至只有一棵树，也即子图

中含有n-1 条边为止。

图的抽象数据类型:

ADT Graph{

数据对象V:V 是具有相同特性的数据元素的集合, 称为点集. 数据关系R:

R={VR}

VR={(v,w)|v,w 属于V,(v,w) 表示v 和w 之间存在的路径}

基本操作P:

CreatGraph(&G,V,VR)

初始条件:V 是图的顶点集,VR 是图中弧的集合. 操作结果: 按V 和VR是定义构造图G.

Sort(edge* ,MGraph *)

初始条件: 图G存在，各边权值已知；

操作结果: 对权值进行排序；

Find(int *, int )

初始条件: 前者为已存在的集合，后者为集合中的元素；操作结果: 查找函数，确定后者所属子集；MiniSpanTree(MGraph *)初始条件: 图G存在，各边权值已知；

操作结果: 生成最小树；

Swapn(edge *, int, int)

初始条件: 图G存在，各边权值已知；操作结果: 交换某两个边的权值；

2 图的存储结构

typedef struct

{

int adj;

int weight;

}AdjMatrix[MAX][MAX];

typedef struct

{

AdjMatrix arc;

int vexnum, arcnum;

}MGraph;

typedef struct

{

int begin;

int end;

int weight;

}edge;

3 本程序包含的模块

}

1）初始化操作，结构体定义；

2）函数声明模块；

3）函数定义模块；

4）主程序模块

Main（）

{

调用函数生成图；判断图是否为空；（空则从新输入）调用函数生成最小生成树；

退出；

二、详细设计

#include

#include

using namespace std;

#define int_max 10000

#define inf 9999

#define max 20

// ????????????????邻接矩阵定义????????typedef struct ArcCell

{

int adj;

char *info;

}ArcCell,AdjMatrix[max][max];

typedef struct

{

char vexs[max];

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)// 创建图用邻接矩阵表示

{

char v1,v2;

int i,j,w;

G.vexnum=7;G.arcnum=12;

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

{

cout cin>>G.vexs[i];

}

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; }

G.arcs[0][1].adj=24; G.arcs[1][0].adj=24; G.arcs[0][2].adj=8;

G.arcs[2][0].adj=8;

G.arcs[0][3].adj=15; G.arcs[3][0].adj=15; G.arcs[1][4].adj=6;

G.arcs[4][1].adj=6;

G.arcs[1][6].adj=3;

G.arcs[6][1].adj=3;

G.arcs[2][4].adj=7;

G.arcs[4][2].adj=7;

G.arcs[2][5].adj=3;

G.arcs[5][2].adj=3;

G.arcs[3][5].adj=5;

G.arcs[5][3].adj=5;

G.arcs[3][6].adj=4;

G.arcs[6][3].adj=4;

G.arcs[4][5].adj=2;

G.arcs[5][4].adj=2;

G.arcs[4][6].adj=9;

G.arcs[6][4].adj=9;

G.arcs[5][6].adj=3;

G.arcs[6][5].adj=3;

cout 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)); arc->adjvex=j;

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;

篇三：数据结构图的遍历实验报告

题目：图的遍历的实现

完成日期：

一、需求分析

1. 本演示程序中，输入的数据类型均为整型数据，不允许输入

字符等其他数据类型，且需要按照提示内容进行输入，成对的关系数

据必须在所建立的图中已经存在对应的结点。

2. 演示程序以用户和计算机的对话方式执行，在计算机终端上

显示的提示信息的说明下，按照要求输入数据，运算结果在其后显

示。

3. 本程序实现分别基于邻接矩阵和邻接表存储结构的有、无向图，有、无向网的建立和遍历。遍历分DFS和BFS

两种算法，并分别以递归和非递归形式实现。

4. 测试数据：

（1）无向图结点数4 弧数3 结点：1 2 3 4 结点关系：1

2 ；1

3 ；2 4

（2）有向图结点数6 弧数6 结点：1 2 3 4 5 6 结点关系：

1 2 ；1 3 ；2 4 ；3 5 ；3 6；2 5

二、概要设计为实现上述程序功能，图的存储结构分为邻接矩阵

和

邻接表两种。遍历过程中借助了栈和队列的存储结构

1. 邻接矩阵存储结构的图定义：

ADT mgraph{

数据对象V：V 是具有相同特性的的数据元素的集合，成为顶

点集。

数据关系R:

R={VR}

VR={ | v,w ? V且P(v,w), 表示从v到w的弧，谓词P(v,w) 定义了弧的意义或信息}

基本操作P ：

locatevex(G, mes) ；

初始条件：图G存在，mes 和G中顶点有相同的特征。

操作结果：若G 中存在顶点u，则返回该顶点在图中位置；否则返回其他信息。

createudn( & G) ；初始条件：图G 存在。操作结果：创建无向图。

createdn( & G) ；初始条件：图G 存在。操作结果：创建有向图。

createudg( & G) ；初始条件：图G 存在操作结果：创建无向网。createdg(& G) ；初始条件：图G 存在。操作结果：创建有向网。

DFS(G,v) ；初始条件：图G 已经存在并被赋值，v 是图中某个顶点的位置坐标。

操作结果：深度优先搜索遍历图G，访问顶点时使用函