数据结构实验六 图的综合应用

实验六  的综合应用

一、实验目的

1.掌握图的基本操作—遍历

2. 掌握图的应用。

二、实验内容

对给定的输入内容,完成实验任务

输入顶点集:1 2 3 4 5 6 7 8

输入边的集合: 1  2

1  3

2  4

2  5

4  8

5  8

3  6

3  7

6  7

1)创建一个图(可用邻接矩阵或邻接表的方式进行存储);

2)输入选项:0或1,0为DFS,1为BFS

3)分别输出DFS和BFS两种遍历序列

三、实验要求

1. 程序要添加适当的注释,程序的书写要采用缩进格式

2. 程序要具在一定的健壮性,即当输入数据非法时,程序也能适当地做出反应,如插入删除时指定的位置不对等等。

3. 程序要做到界面友好,在程序运行时用户可以根据相应的提示信息进行操作。

4. 实验课前完成实验内容源程序的初稿;实验课对源程序进行编辑、调试、运行;实验课后按规定时间上交实验内容。

5. 按照实验内容完成程序编写,并将源代码和运行结果截图粘贴到word文档中,A4正反打印,写清班级和姓名提交

 代码部分

头文件与邻接矩阵、邻接表、辅助队列的定义

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<fstream>
#define MaxInt 32767
#define MVNum 100
using namespace std;
/*邻接定义矩阵*/
typedef struct{
	int vexs[MVNum];//顶点表 
	int arcs[MVNum][MVNum];//邻接矩阵 
	int vexnum,arcnum;
}AMGraph;
/*辅助队列的定义*/ 
typedef struct{
	int *base;
	int frone;
	int rear;
	int maxize;
}SqQueue;
/*邻接表的存储表示*/ 
typedef struct ArcNode{
	int adivex;
	struct ArcNode *nextarc;
}ArcNode;//指针p 
typedef struct VNode{
	int data;
	ArcNode * firstarc;
}Vnode,AdjList[MVNum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;

菜单函数 

/*菜单函数*/
void menu1(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
	cout<<"|---------图的综合应用---------|"<<endl;
	cout<<"|-----------请选择!-----------|"<<endl;
	cout<<"|----1.以邻接矩阵进行存储!----|"<<endl;
	cout<<"|-----2.以邻接表进行存储!-----|"<<endl;
	cout<<"|-----------0.退出!-----------|"<<endl;
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
} 
void menu2(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;	
	cout<<"|-----------请操作!-----------|"<<endl;
	cout<<"|--0.输出邻接矩阵DFS遍历序列!--|"<<endl;
	cout<<"|--1.输出邻接矩阵BFS遍历序列!--|"<<endl;
	cout<<"|-------2.输出邻接矩阵!-------|"<<endl; 
	cout<<"|-----3.重新选择存储方式!-----|"<<endl;
	cout<<"|-----------4.退出!-----------|"<<endl;
	cout<<"|------------------------------|"<<endl;
} 
void menu3(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;	
	cout<<"|-----------请操作!-----------|"<<endl;
	cout<<"|--0.输出邻接表的DFS遍历序列!--|"<<endl;
	cout<<"|--1.输出邻接表的BFS遍历序列!--|"<<endl;
	cout<<"|--------2.输出邻接表!--------|"<<endl; 
	cout<<"|-----3.重新选择存储方式!-----|"<<endl;
	cout<<"|-----------4.退出!-----------|"<<endl;
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
} 
/*菜单函数*/ 

 邻接矩阵与邻接表的下标定位LocateVex函数

int LocateVex1(AMGraph &G,int v){
	for(int i=0;i<=G.vexnum;++i)
		if(v==G.vexs[i])
			return i;
	cout<<"未在图中找到编号为"<<v<<"的点"<<endl; 
	return -1;
}
/*邻接表*/ 
int LocateVex2(ALGraph &g,int v){
	for(int i=0;i<=g.vexnum;++i)
		if(v==g.vertices[i].data)
			return i;
	cout<<"未在图中找到编号为"<<v<<"的点"<<endl; 
	return -1;
}

辅助队列所需使用的基本函数 

/*队列函数*/
void InitQueue(SqQueue &Q,int n){
	Q.base=new int[n];
	Q.maxize=n;
	Q.frone=Q.rear=0;
}
void EnQueue(SqQueue &Q,int v){
	Q.base[Q.rear]=v;
	Q.rear=(Q.rear+1)%Q.maxize;
}
int DeQueue(SqQueue &Q){
	int x=Q.base[Q.frone];
	Q.frone=(Q.frone+1)%Q.maxize;
	return x;
}
int QueueEmpty(SqQueue &Q){
	if(Q.frone==Q.rear)	return 1;
	else return 0;
}

以邻接矩阵存储图 代码部分 

 创建邻接矩阵

/*邻接矩阵存储代码开始*/ 
/*创建邻接矩阵*/ 
void CreatUDNAM(AMGraph &G){
	int i,j,k,v1,v2;
	cout<<"|---请输入总顶点数与总边数!---|"<<endl;
	cin>>G.vexnum>>G.arcnum;
	
	cout<<"|---------请输入顶点值!--------|"<<endl;
	for(i=0;i<G.vexnum;++i){
		cin>>G.vexs[i];
	}
	for(i=0;i<G.vexnum;++i)
		for(j=0;j<G.vexnum;++j)
			G.arcs[i][j]=0;	
	cout<<"|--------请输入边的值!--------|"<<endl; 
	for(k=0;k<G.arcnum;++k){
		cin>>v1>>v2;
		i=LocateVex1(G,v1);
		j=LocateVex1(G,v2);
		if(i==-1||j==-1){
			cout<<"|-----邻接矩阵中无"<<v1<<" "<<v2<<"顶点-----|"<<endl;
			break;
		} 
		G.arcs[i][j]=1;
		G.arcs[j][i]=G.arcs[i][j];
	}

	cout<<"|----以邻接矩阵建立图完成!----|"<<endl; 
}

输出邻接矩阵 

/*输出邻接矩阵*/
void putAMGragp(AMGraph G){
	int i,j;
	cout<<"   ";
	for(i=0;i<G.vexnum;++i)
		cout<<"["<<G.vexs[i]<<"]"<<" ";
	cout<<endl;
	for(i=0;i<G.vexnum;++i){
		cout<<"["<<G.vexs[i]<<"]"<<" ";
		for(j=0;j<G.vexnum;++j){
			cout<<G.arcs[i][j]<<"   ";
		}
			cout<<endl;
	}

	cout<<"|----------输出完成!----------|"<<endl;
}

DFS递归遍历邻接矩阵 

/*建立DFS的visit数组*/ 
bool visitedDFS[MVNum];
/*邻接矩阵的深度优先遍历*/
void DFS_AM(AMGraph G,int v){
	cout<<G.vexs[v]<<" ";
	visitedDFS[v]=true;
	for(int w=0;w<G.vexnum;++w)
		if((G.arcs[v][w]!=0)&&(!visitedDFS[w]))
			DFS_AM(G,w);
}

BFS遍历邻接矩阵 (需要使用辅助队列)

/*建立BFS的visit数组*/ 
bool visitedBFS[MVNum];
/*邻接矩阵的广度优先遍历*/  
void BFS_AM(AMGraph G,int v){//注意返回值 
	SqQueue Q;
	InitQueue(Q,G.vexnum);
	int i,w;
	cout<<G.vexs[v]<<" ";//v=0,输出第一个数 1 
	visitedBFS[v]=true;// 将 0变为 true 
	EnQueue(Q,v);//0入队 
	while(!QueueEmpty(Q)){//结束循环
		w=DeQueue(Q); //队首元素出队(主要用于某一列全部元素读取完成后返回) 
		for(i=0;i<G.vexnum;++i){//从w列遍历 
			if(G.arcs[w][i]==1&&visitedBFS[i]!=true){//判断 
				cout<<G.vexs[i]<<" ";//输出 
				EnQueue(Q,i);//入队 
				visitedBFS[i]=true;	//标记 
			}
		}
	}
	cout<<endl;
}
/*邻接矩阵代码结束*/ 

以邻接表存储图 代码部分

创建邻接表 

/*邻接表代码开始*/
/*创建邻接表*/ 
void CreatUDNAL(ALGraph &g){
	int v1,v2,i,j;
	ArcNode *p1,*p2;

	cout<<"|---请输入总顶点数与总边数!---|"<<endl;
	cin>>g.vexnum>>g.arcnum;//输入总点数与总边数 
	cout<<"|--------请输入顶点值!--------|"<<endl;
	for(int i=0;i<g.vexnum;++i){
		cin>>g.vertices[i].data;//输入点值 
		g.vertices[i].firstarc=NULL;//表头结点的指针域初始化为空 
	}
	cout<<"|--------请输入边的值!--------|"<<endl; 
	for(int k=0;k<g.arcnum;++k){
		cin>>v1>>v2;//输入边的两个顶点 
		i=LocateVex2(g,v1);//定位i 
		j=LocateVex2(g,v2);//定位j 
		p1=new ArcNode;//生成边结点p1 
		p1->adivex=j;//p1的邻接点记为j 
		p1->nextarc=g.vertices[i].firstarc; 
		g.vertices[i].firstarc=p1;
		/*将结点p1插入顶点vi的边表头部*/ 
		p2=new ArcNode;//生成新的边结点p2 
		p2->adivex=i;//p2的邻接定记为i 
		p2->nextarc=g.vertices[j].firstarc;
		g.vertices[j].firstarc=p2;
		/*将结点p2插入顶点vj的边表头部*/
	}	
	cout<<"|-----以邻接表建立图完成!-----|"<<endl; 	
}

DFS递归遍历邻接表 

/*建立DFS的visit数组*/ 
bool visitDFS[MVNum];
/*邻接表的深度优先遍历*/
void DFS_AL(ALGraph g,int v){
	int w;
	cout<<g.vertices[v].data<<" ";//输出第一个 
	visitDFS[v]=true;//标记 
	ArcNode *p;//指针 
	p=g.vertices[v].firstarc;//指向v的邻接点 
	while(p!=NULL){//结束标志为遍历完成 
		w=p->adivex;//找到v的下个点 
		if(visitDFS[w]!=true)//未被访问过的点 
			DFS_AL(g,w);//递归调用,深度遍历 
			p=p->nextarc;
	}
}

 BFS遍历邻接表

/*建立BFS的visit数组*/ 
bool visitBFS[MVNum]; 
/*邻接表的广度优先遍历*/
void BFS_AL(ALGraph &g,int v){
	SqQueue q;
	ArcNode *p;//指针指向邻接表 
	int w;
	InitQueue(q,g.vexnum);//创建队列 
	cout<<g.vertices[v].data<<" ";//输出第一个 
	EnQueue(q,v);//将其入队 
	visitBFS[v]=true;//标志 
	while(!QueueEmpty(q)){//队列非空 
		w=DeQueue(q);//将元素出队 
		p=g.vertices[w].firstarc;//p指向其首结点 
		while(1){//当p的指向为空时候跳出循环 
			if(visitBFS[p->adivex]!=true){//判断是否被遍历过 
				cout<<g.vertices[p->adivex].data<<" ";//输出指针p指向的data 
				visitBFS[p->adivex]=true;//标记 
				EnQueue(q,p->adivex);//将指针p指向的值入队 
			}
			if(p->nextarc==NULL){//若为最后一个结点则跳出该循环 
				break;
			}
			else{
				p=p->nextarc;//不是最后一个结点则p指向下一个结点 
			}
		}
/*功能与上面的循环一样,只是把判断条件提到外面*/
//		while(p){//当p的指向为空时候跳出循环 
//			if(visitBFS[p->adivex]!=true){
//				cout<<g.vertices[p->adivex].data<<" ";
//				visitBFS[p->adivex]=true;
//				EnQueue(q,p->adivex);
//			}
//				p=p->nextarc;
//		}
	}
	cout<<endl;
}

 输出邻接表

/*输出邻接表*/ 
void printf_ALGraph(ALGraph &g){
	ArcNode *p;
	int flag=0;
	for(int i=0;i<g.vexnum;++i){
		p=g.vertices[i].firstarc;
		while(p){
			if(flag){
				cout<<"->";
				cout<<g.vertices[p->adivex].data;
				p=p->nextarc;
			}
			else{
				cout<<"《"<<g.vertices[i].data<<"->"<<g.vertices[p->adivex].data;
				flag=1;
				p=p->nextarc;
			}	
		}
		flag=0;
		cout<<endl;
	}
}
/*邻接表代码结束*/ 

主函数 

/*主函数*/
int main(){
	int choose,n,v=0;
A:	menu1();
	cout<<"请选择操作:";
	cin>>choose;
	if(choose==1){/*邻接矩阵*/ 
	cout<<"|---图将以邻接矩阵进行存储!---|"<<endl;
		AMGraph G;
		CreatUDNAM(G);
		do{
			menu3();
			cout<<"请选择操作:";
			cin>>n;
			switch(n){
				case 0:
					cout<<"该图的深度优先遍历结果为:"; 
					DFS_AM(G,v);
					cout<<endl;
					break;
				case 1:
					cout<<"该图的广度优先遍历结果为:";
					BFS_AM(G,v);
					break;
				case 2:
					cout<<"该图的邻接矩阵为:"<<endl;
					putAMGragp(G); 
					break;
				case 3: goto A;
				case 4: return 0;
			}
		}while(n!=3);
		
	}
	else if(choose==2){/*邻接表*/ 
		cout<<"|----图将以邻接表进行存储!----|"<<endl;
		ALGraph g;
		CreatUDNAL(g);
		do{
			menu2();
			cout<<"请选择操作:";
			cin>>n;
			switch(n){
				case 0:
					cout<<"该图的深度优先遍历结果为:"; 
					DFS_AL(g,v);
					cout<<endl;
					break;
				case 1:
					cout<<"该图的广度优先遍历结果为:";
					BFS_AL(g,v);
					break;
				case 2:
					cout<<"该图的邻接表为:"<<endl;
					printf_ALGraph(g);
					break;
					
				case 3: goto A;
				case 4: return 0;
			}
		}while(n!=3);
	}
	else if(!choose){
		cout<<"欢迎下次使用!"<<endl;
		return 0;
	}
	return 0;
}

完整测试样例:

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<fstream>
#define MaxInt 32767
#define MVNum 100
using namespace std;
/*邻接定义矩阵*/
typedef struct{
	int vexs[MVNum];//顶点表 
	int arcs[MVNum][MVNum];//邻接矩阵 
	int vexnum,arcnum;
}AMGraph;
/*辅助队列的定义*/ 
typedef struct{
	int *base;
	int frone;
	int rear;
	int maxize;
}SqQueue;
/*邻接表的存储表示*/ 
typedef struct ArcNode{
	int adivex;
	struct ArcNode *nextarc;
}ArcNode;//指针p 
typedef struct VNode{
	int data;
	ArcNode * firstarc;
}Vnode,AdjList[MVNum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
/*v的下标定位函数*/
/*邻接矩阵*/ 
int LocateVex1(AMGraph &G,int v){
	for(int i=0;i<=G.vexnum;++i)
		if(v==G.vexs[i])
			return i;
	cout<<"未在图中找到编号为"<<v<<"的点"<<endl; 
	return -1;
}
/*邻接表*/ 
int LocateVex2(ALGraph &g,int v){
	for(int i=0;i<=g.vexnum;++i)
		if(v==g.vertices[i].data)
			return i;
	cout<<"未在图中找到编号为"<<v<<"的点"<<endl; 
	return -1;
}
/*队列函数*/
void InitQueue(SqQueue &Q,int n){
	Q.base=new int[n];
	Q.maxize=n;
	Q.frone=Q.rear=0;
}
void EnQueue(SqQueue &Q,int v){
	Q.base[Q.rear]=v;
	Q.rear=(Q.rear+1)%Q.maxize;
}
int DeQueue(SqQueue &Q){
	int x=Q.base[Q.frone];
	Q.frone=(Q.frone+1)%Q.maxize;
	return x;
}
int QueueEmpty(SqQueue &Q){
	if(Q.frone==Q.rear)	return 1;
	else return 0;
}
/*邻接矩阵存储代码开始*/ 
/*创建邻接矩阵*/ 
void CreatUDNAM(AMGraph &G){
	int i,j,k,v1,v2;
	cout<<"|---请输入总顶点数与总边数!---|"<<endl;
	cin>>G.vexnum>>G.arcnum;
	
	cout<<"|---------请输入顶点值!--------|"<<endl;
	for(i=0;i<G.vexnum;++i){
		cin>>G.vexs[i];
	}
	for(i=0;i<G.vexnum;++i)
		for(j=0;j<G.vexnum;++j)
			G.arcs[i][j]=0;	
	cout<<"|--------请输入边的值!--------|"<<endl; 
	for(k=0;k<G.arcnum;++k){
		cin>>v1>>v2;
		i=LocateVex1(G,v1);
		j=LocateVex1(G,v2);
		if(i==-1||j==-1){
			cout<<"|-----邻接矩阵中无"<<v1<<" "<<v2<<"顶点-----|"<<endl;
			break;
		} 
		G.arcs[i][j]=1;
		G.arcs[j][i]=G.arcs[i][j];
	}

	cout<<"|----以邻接矩阵建立图完成!----|"<<endl; 
}
/*输出邻接矩阵*/
void putAMGragp(AMGraph G){
	int i,j;
	cout<<"   ";
	for(i=0;i<G.vexnum;++i)
		cout<<"["<<G.vexs[i]<<"]"<<" ";
	cout<<endl;
	for(i=0;i<G.vexnum;++i){
		cout<<"["<<G.vexs[i]<<"]"<<" ";
		for(j=0;j<G.vexnum;++j){
			cout<<G.arcs[i][j]<<"   ";
		}
			cout<<endl;
	}

	cout<<"|----------输出完成!----------|"<<endl;
}
/*建立DFS的visit数组*/ 
bool visitedDFS[MVNum];
/*邻接矩阵的深度优先遍历*/
void DFS_AM(AMGraph G,int v){
	cout<<G.vexs[v]<<" ";
	visitedDFS[v]=true;
	for(int w=0;w<G.vexnum;++w)
		if((G.arcs[v][w]!=0)&&(!visitedDFS[w]))
			DFS_AM(G,w);
}
/*建立BFS的visit数组*/ 
bool visitedBFS[MVNum];
/*邻接矩阵的广度优先遍历*/  
void BFS_AM(AMGraph G,int v){//注意返回值 
	SqQueue Q;
	InitQueue(Q,G.vexnum);
	int i,w;
	cout<<G.vexs[v]<<" ";//v=0,输出第一个数 1 
	visitedBFS[v]=true;// 将 0变为 true 
	EnQueue(Q,v);//0入队 
	while(!QueueEmpty(Q)){//结束循环
		w=DeQueue(Q); //队首元素出队(主要用于某一列全部元素读取完成后返回) 
		for(i=0;i<G.vexnum;++i){//从w列遍历 
			if(G.arcs[w][i]==1&&visitedBFS[i]!=true){//判断 
				cout<<G.vexs[i]<<" ";//输出 
				EnQueue(Q,i);//入队 
				visitedBFS[i]=true;	//标记 
			}
		}
	}
	cout<<endl;
}
/*邻接矩阵代码结束*/ 
/*菜单函数*/
void menu1(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
	cout<<"|---------图的综合应用---------|"<<endl;
	cout<<"|-----------请选择!-----------|"<<endl;
	cout<<"|----1.以邻接矩阵进行存储!----|"<<endl;
	cout<<"|-----2.以邻接表进行存储!-----|"<<endl;
	cout<<"|-----------0.退出!-----------|"<<endl;
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
} 
void menu2(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;	
	cout<<"|-----------请操作!-----------|"<<endl;
	cout<<"|--0.输出邻接矩阵DFS遍历序列!--|"<<endl;
	cout<<"|--1.输出邻接矩阵BFS遍历序列!--|"<<endl;
	cout<<"|-------2.输出邻接矩阵!-------|"<<endl; 
	cout<<"|-----3.重新选择存储方式!-----|"<<endl;
	cout<<"|-----------4.退出!-----------|"<<endl;
	cout<<"|------------------------------|"<<endl;
} 
void menu3(){
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;	
	cout<<"|-----------请操作!-----------|"<<endl;
	cout<<"|--0.输出邻接表的DFS遍历序列!--|"<<endl;
	cout<<"|--1.输出邻接表的BFS遍历序列!--|"<<endl;
	cout<<"|--------2.输出邻接表!--------|"<<endl; 
	cout<<"|-----3.重新选择存储方式!-----|"<<endl;
	cout<<"|-----------4.退出!-----------|"<<endl;
	cout<<"<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>"<<endl;
} 
/*菜单函数*/ 
/*邻接表代码开始*/
/*创建邻接表*/ 
void CreatUDNAL(ALGraph &g){
	int v1,v2,i,j;
	ArcNode *p1,*p2;

	cout<<"|---请输入总顶点数与总边数!---|"<<endl;
	cin>>g.vexnum>>g.arcnum;//输入总点数与总边数 
	cout<<"|--------请输入顶点值!--------|"<<endl;
	for(int i=0;i<g.vexnum;++i){
		cin>>g.vertices[i].data;//输入点值 
		g.vertices[i].firstarc=NULL;//表头结点的指针域初始化为空 
	}
	cout<<"|--------请输入边的值!--------|"<<endl; 
	for(int k=0;k<g.arcnum;++k){
		cin>>v1>>v2;//输入边的两个顶点 
		i=LocateVex2(g,v1);//定位i 
		j=LocateVex2(g,v2);//定位j 
		p1=new ArcNode;//生成边结点p1 
		p1->adivex=j;//p1的邻接点记为j 
		p1->nextarc=g.vertices[i].firstarc; 
		g.vertices[i].firstarc=p1;
		/*将结点p1插入顶点vi的边表头部*/ 
		p2=new ArcNode;//生成新的边结点p2 
		p2->adivex=i;//p2的邻接定记为i 
		p2->nextarc=g.vertices[j].firstarc;
		g.vertices[j].firstarc=p2;
		/*将结点p2插入顶点vj的边表头部*/
	}	
	cout<<"|-----以邻接表建立图完成!-----|"<<endl; 	
}
/*建立DFS的visit数组*/ 
bool visitDFS[MVNum];
/*邻接表的深度优先遍历*/
void DFS_AL(ALGraph g,int v){
	int w;
	cout<<g.vertices[v].data<<" ";//输出第一个 
	visitDFS[v]=true;//标记 
	ArcNode *p;//指针 
	p=g.vertices[v].firstarc;//指向v的邻接点 
	while(p!=NULL){//结束标志为遍历完成 
		w=p->adivex;//找到v的下个点 
		if(visitDFS[w]!=true)//未被访问过的点 
			DFS_AL(g,w);//递归调用,深度遍历 
			p=p->nextarc;
	}
}
/*建立BFS的visit数组*/ 
bool visitBFS[MVNum]; 
/*邻接表的广度优先遍历*/
void BFS_AL(ALGraph &g,int v){
	SqQueue q;
	ArcNode *p;//指针指向邻接表 
	int w;
	InitQueue(q,g.vexnum);//创建队列 
	cout<<g.vertices[v].data<<" ";//输出第一个 
	EnQueue(q,v);//将其入队 
	visitBFS[v]=true;//标志 
	while(!QueueEmpty(q)){//队列非空 
		w=DeQueue(q);//将元素出队 
		p=g.vertices[w].firstarc;//p指向其首结点 
		while(1){//当p的指向为空时候跳出循环 
			if(visitBFS[p->adivex]!=true){//判断是否被遍历过 
				cout<<g.vertices[p->adivex].data<<" ";//输出指针p指向的data 
				visitBFS[p->adivex]=true;//标记 
				EnQueue(q,p->adivex);//将指针p指向的值入队 
			}
			if(p->nextarc==NULL){//若为最后一个结点则跳出该循环 
				break;
			}
			else{
				p=p->nextarc;//不是最后一个结点则p指向下一个结点 
			}
		}
/*功能与上面的循环一样,只是把判断条件提到外面*/
//		while(p){//当p的指向为空时候跳出循环 
//			if(visitBFS[p->adivex]!=true){
//				cout<<g.vertices[p->adivex].data<<" ";
//				visitBFS[p->adivex]=true;
//				EnQueue(q,p->adivex);
//			}
//				p=p->nextarc;
//		}
	}
	cout<<endl;
}
/*输出邻接表*/ 
void printf_ALGraph(ALGraph &g){
	ArcNode *p;
	int flag=0;
	for(int i=0;i<g.vexnum;++i){
		p=g.vertices[i].firstarc;
		while(p){
			if(flag){
				cout<<"->";
				cout<<g.vertices[p->adivex].data;
				p=p->nextarc;
			}
			else{
				cout<<"《"<<g.vertices[i].data<<"->"<<g.vertices[p->adivex].data;
				flag=1;
				p=p->nextarc;
			}	
		}
		flag=0;
		cout<<endl;
	}
}
/*邻接表代码结束*/ 
/*主函数*/
int main(){
	int choose,n,v=0;
A:	menu1();
	cout<<"请选择操作:";
	cin>>choose;
	if(choose==1){/*邻接矩阵*/ 
	cout<<"|---图将以邻接矩阵进行存储!---|"<<endl;
		AMGraph G;
		CreatUDNAM(G);
		do{
			menu3();
			cout<<"请选择操作:";
			cin>>n;
			switch(n){
				case 0:
					cout<<"该图的深度优先遍历结果为:"; 
					DFS_AM(G,v);
					cout<<endl;
					break;
				case 1:
					cout<<"该图的广度优先遍历结果为:";
					BFS_AM(G,v);
					break;
				case 2:
					cout<<"该图的邻接矩阵为:"<<endl;
					putAMGragp(G); 
					break;
				case 3: goto A;
				case 4: return 0;
			}
		}while(n!=3);
		
	}
	else if(choose==2){/*邻接表*/ 
		cout<<"|----图将以邻接表进行存储!----|"<<endl;
		ALGraph g;
		CreatUDNAL(g);
		do{
			menu2();
			cout<<"请选择操作:";
			cin>>n;
			switch(n){
				case 0:
					cout<<"该图的深度优先遍历结果为:"; 
					DFS_AL(g,v);
					cout<<endl;
					break;
				case 1:
					cout<<"该图的广度优先遍历结果为:";
					BFS_AL(g,v);
					break;
				case 2:
					cout<<"该图的邻接表为:"<<endl;
					printf_ALGraph(g);
					break;
					
				case 3: goto A;
				case 4: return 0;
			}
		}while(n!=3);
	}
	else if(!choose){
		cout<<"欢迎下次使用!"<<endl;
		return 0;
	}
	return 0;
}

  • 6
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值