湖南大学数据结构试验图遍历问题
湖南大学数据结构实验
HUNAN UNIVERSITY数据结构实验报告题目：实验5四则运算表达式求值学生姓名谢毅学生姓名冯吉禹学生姓名吕志远学生学号20110806109学生学号20110806110学生学号20110806114专业班级信息安全1101班指导老师夏艳完成日期2013 年04 月 19日一．需求分析1、利用二叉树后序遍历来实现表达式的转换，同时可以使用实验3的结果来求解后缀表达式的值。
2、输入输出格式：输入：在字符界面上输入一个中缀表达式，回车表示结束。
输出：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
输入：21+23*（12-6）输出：21 23 12 6 -*+一．概要设计抽象数据类型1.使用二叉树来实现2．本程序包含四个基本模块①主程序模块：建树的过程②没有括号时的输入③有括号时的输入○4后序输出三﹑算法（C++）物理数据类型建树的时候对于优先级比较高的符号最为子结点插入，对于优先级比较低的则作为父结点插入，数据直接插入在字符的左右子结点位置。
/*问题描述四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
基本要求使用二叉树来实现。
实现提示利用二叉树后序遍历来实现表达式的转换，同时可以使用实验3的结果来求解后缀表达式的值。
输入输出格式：输入：在字符界面上输入一个中缀表达式，回车表示结束。
输出：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
*/#include<iostream.h>#include <stdio.h>/*二叉树的节点类*/class Node{public:int num;//元素char c;//操作符Node* lc;//左指针Node* rc;//右指针Node* pa;//父指针Node(int num,Node* lc=NULL,Node* rc=NULL){this->num=num;this->lc=lc;this->rc=rc;}Node(char c,Node* lc=NULL,Node* rc=NULL){this->c=c;this->lc=lc;this->rc=rc;}bool isLeaf(){return (lc==NULL)&&(rc==NULL);}};void Nomal(char &t,char &c,Node* &one,Node* &two);//正常输入void UNomal(char &t,char &c,Node* &one,Node* &two);//带括号输入void BHVisit(Node* root);/*二叉树类*/class TwoTree{private:Node* root;//根节点Node* present;//当前表达式节点public:TwoTree(){root=NULL;present=root;}Node* getroot(){return root;}bool gt(Node* two,Node* present)//比较优先级的函数{char ct=two->c;char cp=present->c;if(ct=='*'||ct=='/')if(cp=='+'||cp=='-')return true;return false;}void insert(Node* one,Node* two=NULL)//向插入的方法{cout<<" 要插入了 "<<one->num<<" "<<two->c<<endl;if(root==NULL){root=two;root->lc=one;one->pa=root;present=root;return;}if(two->c=='\n'){present->rc=one;one->pa=present;return;}if(gt(two,present))//如果输入的操作符的优先等级大于当前指针的优先级{two->lc=one;one->pa=two;present->rc=two;two->pa=present;present=two;return;}present->rc=one;while(!gt(two,present)&&present!=root)//如果输入的操作符的优先等级不大于当前指针的优先级{present=present->pa;//指向父节点}if(gt(two,present))//如果输入的操作符的优先等级大于当前指针的优先级{two->lc=present->rc;present->rc->pa=two;present->rc=two;two->pa=present;present=two;return;}else{two->lc=present;present->pa=two;root=two;present=two;}}};void main(){TwoTree tt;Node* root;Node* one;Node* two;char c,t;int index=0;cout<<"请输入一个中缀表达式"<<endl;while(1){t=getchar();cout<<t<<endl;if(t!='(')Nomal(t,c,one,two);elseUNomal(t,c,one,two);tt.insert(one,two);if(c=='\n')break;}root=tt.getroot();BHVisit(root);return;}void Nomal(char &t,char &c,Node* &one,Node* &two) {int num;num=t-'0';cout<<num<<"--------"<<endl;c=getchar();one=new Node(num);two=new Node(c);}void UNomal(char &t,char &c,Node* &one,Node* &two) {int num;TwoTree ttp;while(1){t=getchar();num=t-'0';cout<<num<<"+++++++++++"<<t<<endl;c=getchar();if(c==')'){char cp='\n';c=getchar();one=new Node(num);two=new Node(cp);ttp.insert(one,two);break;}one=new Node(num);two=new Node(c);ttp.insert(one,two);}one=ttp.getroot();two=new Node(c);}void BHVisit(Node* root)//后序遍历函数{if(root==NULL)return;BHVisit(root->lc);BHVisit(root->rc);if(root->isLeaf())cout<<root->num<<" ";elsecout<<root->c<<" ";}六．算法的时间复杂度：整个程序的时间复杂度是O(n).七．实验心得谢毅：本次实验相对上次实验来说难度提升比较大，刚开始的时候觉得无从下手，后来翻阅了书上的关于树的内容，并且和同学们经过了讨论，终于想出了这次实验的建树方式。
数据结构实验五---图的遍历及其应用实现
数据结构实验五---图的遍历及其应用实现实验五图的遍历及其应用实现一、实验目的1．熟悉图常用的存储结构。
2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。
3．会用图的遍历解决简单的实际问题。
二、实验内容[题目] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。
该程序包括图类型以及每一种操作的具体的函数定义和主函数。
三、实验步骤（一）、数据结构与核心算法的设计描述：本实验主要在于图的基本操作，关键是图的两种遍历，仔细分析图的遍历的特点，不难发现，其符合递归的特点，因此可以采用递归的方法遍历。
本实验图的存储结构主要采用邻接表，总共分为四个模块：图的创建、位置的查找、深度优先遍历、广度优先遍历。
以下是头文件中数据结构的设计和相关函数的声明：#include#include#include#nclude#define OVERFLOW -2#define MAX_VERTEX_NUM 50 //最大顶点数#define MAXQSIZE 100# define OK 1typedef int VRType;typedef int InfoType;typedef int QElemType;typedef enum{DG,DN,UDG,UDN}GraphKind;typedef struct ArcNode // 弧结点{int adjvex; //邻接点域，存放与Vi邻接的点在表头数组中的位置struct ArcNode *nextarc; //链域指向vi的下一条边或弧的结点，InfoType *info; //定义与弧相关的权值，无权则为0 }ArcNode;typedef struct VNode //表头结点{char vexdata; //存放顶点信息struct ArcNode *firstarc; //指示第一个邻接点}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{ //图的结构定义AdjList vertices; //顶点向量int vexnum, arcnum; //vexnum为顶点数arcnum为弧或边的个数GraphKind kind; // 图的种类标志}MGraph;typedef struct Queue //构建循环队列{QElemType *base;int front;int rear;}Queue;void CreateGraph(MGraph &G); //图的创建void DFSTraverse(MGraph &G) ; //深度优先遍历void BFSTraverse(MGraph &G); //广度优先遍历int LocateVex(MGraph &G, char &v);//查找顶点v的位置（二）、函数调用及主函数设计void main(){int x;MGraph G;CreateGraph(G);cout<<"创建图成功!"<<endl;< p="">cout<<"1 深度优先搜索"<<endl<<"2 p="" 广度优先搜索"<<endl;<="">cin>>x;if(x==1){DFSTraverse(G);cout<<"深度优先搜索结束!"<<endl;< p="">}else if(x==2){BFSTraverse(G);cout<<"广度优先搜索结束!"<<endl;< p="">}elsecout<<"输入有误!"<<endl<<"再见!"<<endl;< p="">}（三）、实验总结由于图的基本操作在图这一章节中起着很主要的作用，所以在实验前就对实验做了充分的准备，实验的成功核心在于两种遍历的实现，因此只有充分理解遍历算法的精髓，才能更好的做好实验。
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法1. 深度优先搜索（DFS）深度优先搜索是一种常用的图遍历算法，其基本思想是从一个顶点出发，沿着一条路径向来向下访问，直到无法继续为止，然后回溯到前一个顶点，再选择此外一条路径继续访问。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问。
（2）从v出发，选择一个未被访问的邻接顶点w，将w标记为已访问，并将w入栈。
（3）如果不存在未被访问的邻接顶点，则出栈一个顶点，继续访问其它未被访问的邻接顶点。
（4）重复步骤（2）和（3），直到栈为空。
2. 广度优先搜索（BFS）广度优先搜索是另一种常用的图遍历算法，其基本思想是从一个顶点出发，挨次访问其所有邻接顶点，然后再挨次访问邻接顶点的邻接顶点，以此类推，直到访问完所有顶点。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问，并将v入队。
（2）从队首取出一个顶点w，访问w的所有未被访问的邻接顶点，并将这些顶点标记为已访问，并将它们入队。
（3）重复步骤（2），直到队列为空。
三、图的遍历应用图的遍历算法在实际应用中有广泛的应用，下面介绍两个典型的应用场景。
1. 连通分量连通分量是指图中的一个子图，其中的任意两个顶点都是连通的，即存在一条路径可以从一个顶点到达另一个顶点。
图的遍历算法可以用来求解连通分量的个数及其具体的顶点集合。
具体步骤如下：（1）对图中的每一个顶点进行遍历，如果该顶点未被访问，则从该顶点开始进行深度优先搜索或者广度优先搜索，将访问到的顶点标记为已访问。
（2）重复步骤（1），直到所有顶点都被访问。
2. 最短路径最短路径是指图中两个顶点之间的最短路径，可以用图的遍历算法来求解。
数据结构实验报告图的遍历
数据结构实验报告图的遍历一、实验目的本实验旨在通过实践的方式学习图的遍历算法，掌握图的深度优先搜索（DFS）和广度优先搜索（BFS）的实现方法，加深对数据结构中图的理解。
二、实验步骤1. 创建图的数据结构首先，我们需要创建一个图的数据结构，以方便后续的操作。
图可以使用邻接矩阵或邻接表来表示，这里我们选择使用邻接矩阵。
class Graph:def__init__(self, num_vertices):self.num_vertices = num_verticesself.adj_matrix = [[0] * num_vertices for _ in range(num_vertic es)]def add_edge(self, v1, v2):self.adj_matrix[v1][v2] =1self.adj_matrix[v2][v1] =1def get_adjacent_vertices(self, v):adjacent_vertices = []for i in range(self.num_vertices):if self.adj_matrix[v][i] ==1:adjacent_vertices.append(i)return adjacent_vertices2. 深度优先搜索（DFS）DFS是一种遍历图的算法，其基本思想是从图的某一顶点开始，沿着一条路径一直走到最后，然后返回尚未访问过的顶点继续遍历，直到所有顶点都被访问过为止。
def dfs(graph, start_vertex):visited = [False] * graph.num_verticesstack = [start_vertex]while stack:vertex = stack.pop()if not visited[vertex]:print(vertex)visited[vertex] =Truefor neighbor in graph.get_adjacent_vertices(vertex):if not visited[neighbor]:stack.append(neighbor)3. 广度优先搜索（BFS）BFS同样是一种遍历图的算法，其基本思想是从图的某一顶点开始，首先访问其所有邻接点，然后再依次访问邻接点的邻接点，直到所有顶点都被访问过为止。
数据结构实验报告-图的遍历
数据结构实验报告实验：图的遍历一、实验目的：1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表2、掌握图的构造方法3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法4、掌握图的深度优先遍历和广度优先原理二、实验内容：1、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接矩阵存储改图。
2、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接表存储该图3、深度优先遍历第一步中构造的图G，输出得到的节点序列4、广度优先遍历第一部中构造的图G，输出得到的节点序列三、实验要求：1、无向图中的相关信息要从终端以正确的方式输入；2、具体的输入和输出格式不限；3、算法要具有较好的健壮性，对错误操作要做适当处理；4、程序算法作简短的文字注释。
四、程序实现及结果：1、邻接矩阵：#include <stdio.h>#include <malloc.h>#define VERTEX_MAX 30#define MAXSIZE 20typedef struct{intarcs[VERTEX_MAX][VERTEX_MAX] ;int vexnum,arcnum;} MGraph; void creat_MGraph1(MGraph *g) { int i,j,k;int n,m;printf("请输入顶点数和边数:");scanf("%d%d",&n,&m);g->vexnum=n;g->arcnum=m;for (i=0;i<n;i++)for (j=0;j<n;j++)g->arcs[i][j]=0;while(1){printf("请输入一条边的两个顶点：\n");scanf("%d%d",&i,&j);if(i==-1 || j==-1)break;else if(i==j || i>=n || j>=n){printf("输入错误,请重新输入！\n");}else{g->arcs[i][j]=1;g->arcs[j][i]=1;}}}void printMG(MGraph *g) {int i,j;for (i=0;i<g->vexnum;i++){for (j=0;j<g->vexnum;j++)printf(" %d",g->arcs[i][j]);printf("\n");}printf("\n");}main(){int i,j;int fg;MGraph *g1;g1=(MGraph*)malloc(sizeof(MGraph));printf("1:创建无向图的邻接矩阵\n\n");creat_MGraph1(g1);printf("\n此图的邻接矩阵为：\n"); printMG(g1);}2、邻接链表:#include<stdio.h>#include<malloc.h>#define MAX_SIZE 10typedef struct node{int vertex;struct node *next;}node,adjlist[MAX_SIZE];adjlist g;int visited[MAX_SIZE+1];int que[MAX_SIZE+1];void creat(){int n,e;int i;int start,end;node *p,*q,*pp,*qq;printf("输入无向图的顶点数和边数:");scanf("%d%d",&n,&e);for(i = 1; i <= n ; i++){visited[i] = 0;g[i].vertex = i;g[i].next = NULL;}printf("依次输入边:\n");for(i = 1; i <= e ; i++){scanf("%d%d",&start,&end);p=(node *)malloc(sizeof(node));p->vertex = end;p->next = NULL;q = &g[start];while(q->next)q = q->next;q->next = p;p1=(node*)malloc(sizeof(node));p1->vertex = start;p1->next = NULL;q1 = &g[end];while(qq->next)q1 = q1->next;q1->next = p1;}}void bfs(int vi){int front,rear,v;node *p;front =0;rear = 1;visited[vi] = 1;que[0] = vi;printf("%d ",vi);while(front != rear){v = que[front];p = g[v].next;while(p){if(!visited[p->vertex]){visited[p->vertex]= 1;printf("%d",p->vertex);que[rear++] = p->vertex;}p = p->next;}front++;}}int main(){creat();bfs(1);printf("\n");return 0;}五．实验心得与体会：(1)通过这次实验，使我基本上掌握了图的存储和遍历，让我弄清楚了如何用邻接矩阵和邻接链表对图进行存储(2)深度优先遍历和广度优先遍历都有着各自的优点，通过程序逐步调试，可以慢慢的理解这两种遍历方法的内涵和巧妙之处。
数据结构实验报告九—图的遍历
问题描述：若用有向网表示网页的链接网络，其中顶点表示某个网页，有向弧表示网页之间的链接关系。
试设计一个网络蜘蛛系统，分别以广度优先和深度优先的策略抓取网页。
一、需求分析：1．本程序要求采用利用图实现广度优先搜索。
2．首先输入顶点的数量，然后是各顶点对应的字母，再输入各条弧（权值都置为1）。
3．在Dos界面输出从首个顶点开始的广度优先遍历序列。
4．测试数据输入输入顶点数和弧数:8 9输入8个顶点.输入顶点0:a输入顶点1:b输入顶点2:c输入顶点3:d输入顶点4:e输入顶点5:f输入顶点6:g输入顶点7:h输入9条弧.输入弧0:a b 1输入弧1:b d 1输入弧2:b e 1输入弧3:d h 1输入弧4:e h 1输入弧5:a c 1输入弧6:c f 1输入弧7:c g 1输入弧8:f g 1输出广度优先遍历: a b d h e c f g深度优先遍历: a b c d e f g h二、概要设计：抽象数据类型：图的定义：ADT Graph {数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。
数据关系R：R={VR}VR={<v,w>|v,w∈v且P(v,w),<v,w>表示从v到w的弧，谓词P(v,w)定义了弧<v,w>的意义或信息}基本操作P：CreateGraph(&G,V,VR)初始条件：V是图的顶点集，VR是图中弧的集合操作结果：按V和VR的定义构造图GFirstAdjV ex(G,v)初始条件：图G存在,v是G中某个顶点操作结果：返回v的第一个邻接顶点，若顶点在G中没有邻接顶点，则返回“空”Next AdjV ex(G,v,w)初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点操作结果：返回v的（相对于w的）下一个邻接顶点，若w是v的最后一个邻接点，则返回“空”visit(G, k)初始条件：图G存在操作结果：访问图G中的第K个节点Locate(G, c)初始条件：图G存在操作结果：访问图G中的c顶点DFS(G, v)初始条件：图G存在操作结果：以图G中的第v个节点为起点深度优先访问图GBFS(G)初始条件：图G存在操作结果：广度优先访问图G} ADT Graph算法的基本思想：（1）图的特点是没有首尾之分，所以算法的参数要指定访问的第一个顶点。
数据结构图的遍历实验报告
实验项目名称：图的遍历一、实验目的应用所学的知识分析问题、解决问题，学会用建立图并对其进行遍历，提高实际编程能力及程序调试能力。
二、实验内容问题描述：建立有向图，并用深度优先搜索和广度优先搜素。
输入图中节点的个数和边的个数，能够打印出用邻接表或邻接矩阵表示的图的储存结构。
三、实验仪器与设备计算机，Code::Blocks。
四、实验原理用邻接表存储一个图，递归方法深度搜索和用队列进行广度搜索，并输出遍历的结果。
五、实验程序及结果#define INFINITY 10000 /*无穷大*/#define MAX_VERTEX_NUM 40#define MAX 40#include<>#include<>#include<>#include<>typedef struct ArCell{int adj;}ArCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{ char name[20];}infotype;{ infotype vexs[MAX_VERTEX_NUM];AdjMatrix arcs;int vexnum,arcnum;}MGraph;int LocateVex(MGraph *G,char* v){ int c = -1,i;for(i=0;i<G->vexnum;i++)if(strcmp(v,G->vexs[i].name)==0){ c=i; break;}return c;}MGraph * CreatUDN(MGraph *G)d:",i+1);scanf("%s",G->vexs[i].name);}for(i=0;i<G->vexnum;i++)for(j=0;j<G->vexnum;j++)G->arcs[i][j].adj=INFINITY;printf("请输入一条边依附的两个顶点和权值:\n");for(k=0;k<G->arcnum;k++){printf("第%d条边:\n",k+1);printf("起始结点:");scanf("%s",v1);printf("结束结点:");scanf("%s",v2);dj=w;G->arcs[j][i]=G->arcs[i][j];}}return G;}int FirstAdjVex(MGraph *G,int v){int i;if(v<=0 && v<G->vexnum){ dj!=INFINITY)return i;}return -1;}void VisitFunc(MGraph *G,int v){printf("%s ",G->vexs[v].name);}int NextAdjVex(MGraph *G,int v,int w){int k;if(v>=0 && v<G->vexnum && w>=0 && w<G->vexnum)dj!=INFINITY) return k;return -1;}int visited[MAX];void DFS(MGraph *G,int v)//从第v个顶点出发递归地深度优先遍历图G {int w;visited[v]=1;VisitFunc(G,v);//访问第v个结点for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))if(!visited[w]){DFS(G,w);printf("%d ",G->arcs[v][w]);}}void DFSTraverse(MGraph *G,char *s)//深度优先遍历{int v,k;for(v=0;v<G->vexnum;v++)visited[v]=0;k=LocateVex(G,s);if(k>=0&&k<G->vexnum){for(v=k;v>=0;v--){if(!visited[v])DFS(G,v);}for(v=k+1;v<G->vexnum;v++)if(!visited[v])DFS(G,v);}}typedef struct Qnode{int vexnum;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;}void EnQueue(LinkQueue *Q,int a )QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(0);p->vexnum=a;p->next=NULL;Q->rear->next=p;Q->rear=p;}int DeQueue(LinkQueue *Q,int *v){ QueuePtr p;if(Q->front==Q->rear){printf("结点不存在!\n");exit(0);}p=Q->front->next;*v=p->vexnum;Q->front->next=p->next;if(Q->rear==p)Q->front=Q->rear;return *v;}int QueueEmpty(LinkQueue *Q){if(Q->rear==Q->front)return 0;return 1;}int Visited[MAX];void BFSTraverse(MGraph *G,char *str)//广度优先遍历{int w,u,v,k;LinkQueue Q,q;for(v=0;v<G->vexnum;v++) Visited[v]=0;InitQueue(&Q);InitQueue(&q);k=LocateVex(G,str);for(v=k;v>=0;v--)if(!Visited[v]){Visited[v]=1;VisitFunc(G,v);EnQueue(&Q,v);//v入队while(!QueueEmpty(&Q)){DeQueue(&Q,&u);//出队for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))if(!Visited[w]){VisitFunc(G,v);EnQueue(&Q,w);}}}for(v=k+1;v<G->vexnum;v++)if(!Visited[v]){Visited[v]=1;VisitFunc(G,v);EnQueue(&Q,v);//v入队while(!QueueEmpty(&Q)){DeQueue(&Q,&u);//出队for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w)) if(!Visited[w]){Visited[w]=1;VisitFunc(G,v);EnQueue(&Q,w);}}}}void main(){MGraph *G,b;char v[10];G=CreatUDN(&b);printf("请输入起始结点名称:");scanf("%s",v);printf("\n深度优先遍历:\n");DFSTraverse(G,v);printf("\n广度优先遍历:\n");BFSTraverse(G,v);getch();}六、实验总结实验要求输入图中节点的个数和边的个数，能够打印出用邻接表或邻接矩阵表示的图的储存结构。
图的遍历实验报告
1.问题描述：不少涉及图上操作的算法都是以图的遍历操作为基础的。
试写一个程序，演示在连通的无向图上访问全部结点的操作。
2.基本要求：以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。
3.测试数据：教科书图7.33。
暂时忽略里程，起点为北京。
4.实现提示：设图的结点不超过30个，每一个结点用一个编号表示(如果一个图有n个结点，则它们的编号分别为1,2,…,n)。
通过输入图的全部边输入一个图，每一个边为一个数对，可以对边的输入顺序作出某种限制，注意，生成树的边是有向边，端点顺序不能颠倒。
5.选作内容：(1) .借助于栈类型(自己定义和实现)，用非递归算法实现深度优先遍历。
(2) .以邻接表为存储结构，建立深度优先生成树和广度优先生成树，再按凹入表或者树形打印生成树。
1.为实现上述功能，需要有一个图的抽象数据类型。
该抽象数据类型的定义为：ADT Graph{V 是具有相同特性的数据元素的集合，称为顶点集。
R={VR}VR={<v，w> | v ，w v 且P(v，w)，<v，w>表示从v 到w 得弧，谓词P(v，w)定义了弧<v，w>的意义或者信息}} ADT Graph2.此抽象数据类型中的一些常量如下：#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};3.树的结构体类型如下所示：typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。
图--0,1;网--权值int *Info; //与弧相关的信息的指针,可省略}ArcCell, AdjMatrix[max_n][max_n];typedef struct{VertexType vexs[max_n]; //顶点AdjMatrix arcs; //邻接矩阵int vexnum, arcnum; //顶点数，边数}MGraph;//队列的类型定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4.本程序包含三个模块1).主程序模块void main( ){创建树；深度优先搜索遍历；广度优先搜索遍历；}2).树模块——实现树的抽象数据类型3).遍历模块——实现树的深度优先遍历和广度优先遍历各模块之间的调用关系如下：主程序模块树模块遍历模块#include "stdafx.h"#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
HUNAN UNIVERSITY课程实习报告题目：图的遍历问题学生姓名刘乐学生学号20080820208专业班级通信工程2班指导老师朱宁波完成日期2010年5月17日一、问题描述:从图中某个顶点出发访问图中所有顶点，且使得每一顶点仅被访问一次，这个过程称为图的遍历。
图的遍历是从图中某个顶点出发，沿着某条搜索路径对图中其余每个顶点进行访问, 并且使图中的每个顶点仅被访问一次的过程。
二、基本要求：1、实现无向图的深度优先遍历和广度优先遍历。
2、分别输出每种遍历下的结点访问序列.从图中某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。
它是许多图的算法的基础。
三、实验主要模块构造思想：深度优先搜索的过程a 基本思想:首先访问图中某一个指定的出发点Vi；然后任选一个与顶点Vi相邻的未被访问过的顶点Vj；以Vj为新的出发点继续进行深度优先搜索，直至图中所有顶点均被访问过。
b具体过程:设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。
若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y 出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。
上述过程直至从x出发的所有边都已检测过为止。
此时，若x不是源点，则回溯到在x之前被访问过的顶点；否则图中所有和源点有路径相通的顶点(即从源点可达的所有顶点)都已被访问过，若图G是连通图，则遍历过程结束，否则继续选择一个尚未被访问的顶点作为新源点，进行新的搜索过程。
广度优先遍历（Breadth-First Traverse）:特点：尽可能先从指定的出发点，横向地访问图中各个顶点。
1．广度优先遍历的定义在访问了起始点之后,首先依次访问起始点的各个邻接点,然后依次访问这些顶点中未被访问过的邻接点.依此类推,直到所有被访问到的顶点的邻接点都被访问过为止.2. 广度优先搜索的过程a算法基本思想：首先访问图中某一指定的出发点Vi；然后依次访问Vi的所有接点Vi1，Vi2…Vit；再次访问Vi1，Vi2…，Vit的邻接点中未经访问过的顶点，依此类推，直到图中所有顶点均被访问为止。
b具体过程：从广度优先搜索遍历方法可知，先被访问的顶点的邻接点也被访问，即假设顶点V在W之前被访问，那么顶点V的所有未经访问的邻接点也在顶点W的所有未经访问的邻接点之前被访问。
这样可以在广度优先遍历的算法中设置一个队列结构，用以保存已访问过的顶点的序号，访问该顶点的所有未经访问的顶点。
广度优先搜索是一种分层的搜索过程，每向前走一步可能访问一批顶点，不像深度优先搜索那样会出现回退的现象。
因此它不是个递归的过程。
为了实现逐层访问，算法中使用了一个队列以记忆正在访问的这一层和上一层的顶点，以便于向下一层访问。
为了避免重复访问，需要一个辅助函数visitvex[]给被访问过的顶点加标记。
四、设计概要：数据类型及函数定义定义图typedef struct{int V[M];int R[M][M];int vexnum;}Graph;创建图void creatgraph(Graph *g,int n) 打印图的邻接矩阵void printgraph(Graph *g)访问顶点void visitvex(Graph *g,int vex) 深度递归遍历void dfs(Graph *g,int vex) 队列的基本操作定义队列typedef struct{int V[M];int front;int rear;}Queue;判断队列是否为空quempty(Queue *q)入队操作enqueue(Queue *q,int e)出队操作dequeue(Queue *q)广度遍历void BESTraverse(Graph *g)本程序包含四个模块：主程序模块void main (){构造一个图；打印图的邻接矩阵进行深度优先遍历图；进行广度优先遍历图；}；五、算法分析设计：算法一：存在的问题：图中可能存在回路，且图的任一顶点都可能与其他顶点相通，在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点解决办法:为了避免重复访问，可设置一个标志顶点是否被访问过的辅助标志visitvex 辅助数组visitvex 的初始状态为0，在图的遍历过程中，一旦此顶点被访问，就立刻让visitvex为1，防止它被多次访问Visitevex[0．．n-1]的设置：图中任一顶点都可能和其它顶点相邻接。
在访问了某顶点之后，又可能顺着某条回路又回到了该顶点。
为了避免重复访问同一个顶点，必须记住每个已访问的顶点。
为此，可设一布尔向量visitvex[0．．n-1]，其初值为假，一旦访问了顶点Vi之后，便将visitvex[i]置为真。
算法二：以邻接矩阵为存储结构的图的深度优先搜索遍历的算法void dfs(Graph *g,int vex){int w;visited[vex]=1; 标记vex已被访问过visitvex(g,vex); 访问图g的顶点for(w=firstadjvex(g,vex);w>0;w=nextadjvex(g,vex,w))if(!visited[w]){dfs(g,w);}}从初始点vex出发广度优先搜索由邻接矩阵R表示的图void dfstraverse(Graph *g){int i;for(i=1;i<=g->vexnum;i++)visited[i]=0;for(i=1;i<=g->vexnum;i++)if(!visited[i]){dfs(g,i);}}算法三：以邻接矩阵为存储结构的图的广度优先搜索遍历的算法从初始点vex出发广度优先搜索由邻接矩阵R表示的图void BESTraverse(Graph *g){int i;Queue *q=(Queue *)malloc(sizeof(Queue)); 定义一个队列q，其元素类型应为Queue型for(i=1;i<=g->vexnum;i++){visited[i]=0; 标记初始点i未被已访问过}initqueue(q); 初始化队列for(i=1;i<=g->vexnum;i++){if(!visited[i]){visited[i]=1; 标记初始点i已访问过visitvex(g,g->V[i]); 访问顶点ienqueue(q,g->V[i]); 将已访问过的初始点序号i入队while(!quempty(q)) 当队列非空时进行循环处理{ 依次搜索i的每一个可能的邻接点int u,w;u=dequeue(q);for(w=firstadjvex(g,u);w>0;w=nextadjvex(g,u,w)){if(!visited[w]){visited[w]=1; 访问一个未被访问过的邻接点visitvex(g,w); 访问顶点wenqueue(q,w); 顶点w出队}}}}}}本程序划分为三个不同的模块分别编译。
其优点在于编译时如果有错误，只需要对出错的模块进行重新编译，无错的模块则不必再编译。
因而可以明显地节约整个程序的编译调试时间。
用预处理命令#include可以包含有关文件的信息。
#inlcude命令经过预处理命令（即在编译前进行的处理）后，会将其后有关文件的内容拷贝到命令所在的源程序文件中。
该文件里包括常量的定义、结构的定义、函数原型的说明（即函数的返回类型、函数名以及函数参数类型的说明）等六、运行结果：运行说明：本实验以0—7共八个数来代表a-h8个顶点，得到结果与预期相同。
实验体会：本次实验通过对图实现深度优先遍历和广度优先遍历，使我感受到这两种遍历方法的区别与联系即都能拿邻接矩阵来逐步实现，这最先从离散数学学到的内容，拿到这里派上了大用场，各学科的联系在此程序取得交集，是很让人有提高的。
实验源程序：#define M 20#include <stdio.h>#include <stdlib.h>#include <malloc.h>/*定义图*/typedef struct{int V[M];int R[M][M];int vexnum;}Graph;/*创建图*/void creatgraph(Graph *g,int n){int i,j,r1,r2;g->vexnum=n;/*顶点用i表示*/for(i=1;i<=n;i++){g->V[i]=i;}/*初始化R*/for(i=1;i<=n;i++)for(j=1;j<=n;j++){g->R[i][j]=0;}/*输入R*/printf("Please input R(0,0 END):\n"); scanf("%d,%d",&r1,&r2);while(r1!=0&&r2!=0){g->R[r1][r2]=1;g->R[r2][r1]=1;scanf("%d,%d",&r1,&r2);}}/*打印图的邻接矩阵*/void printgraph(Graph *g){int i,j;for(i=1;i<=g->vexnum;i++){ for(j=1;j<=g->vexnum;j++){printf("%2d ",g->R[i][j]);}printf("\n");}}/*全局变量：访问标志数组*/int visited[M];/*访问顶点*/void visitvex(Graph *g,int vex){printf("%d ",g->V[vex]);}/*获取第一个未被访问的邻接节点*/int firstadjvex(Graph *g,int vex){int w,i;for(i=1;i<=g->vexnum;i++){if(g->R[vex][i]==1&&visited[i]==0){w=i;break;}else{w=0;}}return w;}/*获取下一个未被访问的邻接节点(深度遍历)*/int nextadjvex(Graph *g,int vex,int w){int t;t=firstadjvex(g,w);return t;}/*深度递归遍历*/void dfs(Graph *g,int vex){int w;visited[vex]=1;visitvex(g,vex);for(w=firstadjvex(g,vex);w>0;w=nextadjvex(g,vex,w)) if(!visited[w]){dfs(g,w);}}void dfstraverse(Graph *g){int i;for(i=1;i<=g->vexnum;i++)visited[i]=0;for(i=1;i<=g->vexnum;i++)if(!visited[i]){dfs(g,i);}}/*定义队列*/typedef struct{int V[M];int front;int rear;}Queue;/*初始化队列*/initqueue(Queue *q){q->front=0;q->rear=0;}/*判断队列是否为空*/int quempty(Queue *q){if(q->front==q->rear){return 0;}else{return 1;}}/*入队操作*/enqueue(Queue *q,int e){if((q->rear+1)%M==q->front){printf("The queue is overflow!\n"); return 0;}else{q->V[q->rear]=e;q->rear=(q->rear+1)%M;return 1;}}/*出队操作*/dequeue(Queue *q){int t;if(q->front==q->rear){printf("The queue is empty!\n");return 0;}else{t=q->V[q->front];q->front=(q->front+1)%M;return t;}}/*广度遍历*/void BESTraverse(Graph *g){int i;Queue *q=(Queue *)malloc(sizeof(Queue));for(i=1;i<=g->vexnum;i++){visited[i]=0;}initqueue(q);for(i=1;i<=g->vexnum;i++){if(!visited[i]){visited[i]=1;visitvex(g,g->V[i]);enqueue(q,g->V[i]);while(!quempty(q)){int u,w;u=dequeue(q);for(w=firstadjvex(g,u);w>0;w=nextadjvex(g,u,w)) {if(!visited[w]){visited[w]=1;visitvex(g,w);enqueue(q,w);}}}}}}/*主程序*/main(){int n;Graph *g=(Graph *)malloc(sizeof(Graph));char menu;printf("Please input the number of vertex:\n");scanf("%d",&n);creatgraph(g,n);printf("This is the linjiejuzhen of graph:\n");printgraph(g);input:printf("Please input b or d or q ,Breadth_first: b Depth_first: d quit: q\n");while((menu=getchar())=='\n');if(menu=='b'){printf("Breadth_first:\n");BESTraverse(g);printf("\n");goto input;}else if(menu=='d'){printf("Depth_first:\n");dfstraverse(g);printf("\n");goto input;}else if(menu=='q'){exit(0);}else{printf("Input error!Please input b or d!\n");}}。