数据结构之图的DFS和BFS递归与非递归遍历

一、邻接矩阵的DFS递归遍历

/*
Author: luuuuyang
Date: 2018/11/1
Version 1.0
Functions:创建无向网络邻接矩阵即带权无向图+递归DFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MaxInt 32767//表示无穷大(大于任何权值) 
#define MVnum 100 //Max Vertex Number 
typedef char VertexType;//顶点数据类型 
typedef int ArcType;//权值数据类型 
typedef struct{
	VertexType vexs[MVnum];//保存顶点的数组 
	ArcType arcs[MVnum][MVnum];//arcs[i][j]=w 
	int vexnum,arcnum;//顶点数;边数 
}AMGraph;
int LocateVex(AMGraph G,VertexType v){//查找v在G中的数组下标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vexs[i]==v){
			return i;
			break;
		}
}
void CreateUDN(AMGraph &G){
	cout<<"请输入无向网络的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//输入无向网的顶点数和边数
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++) cin>>G.vexs[i];//保存顶点信息 
	for(int i=0;i<G.vexnum;i++)//初始化所有边的权值为无限大 
		for(int j=0;j<G.vexnum;j++)
			G.arcs[i][j]=MaxInt;
	VertexType v1,v2;//定义两点和一边 
	ArcType w;
	cout<<"请输入两顶点以及两顶点的权值:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2>>w;//输入两点和一边 
		int i=LocateVex(G,v1);//查找v1,v2在顶点数组中的下标 
		int j=LocateVex(G,v2);
		G.arcs[i][j]=w;//赋值  i->j=w   j->i=w 
		G.arcs[j][i]=w;
	}
}
bool visit[MVnum];
void DFS_AM(AMGraph G,int v){
	cout<<G.vexs[v];
	visit[v]=1;
	for(int w=0;w<G.vexnum;w++)
		if(G.arcs[v][w]!=MaxInt&&!visit[w]) DFS_AM(G,w);
} 
int main(){
	memset(visit,0,sizeof(visit));
	AMGraph G;
	CreateUDN(G);
	cout<<"邻接矩阵递归DFS遍历的结果为:"; 
	DFS_AM(G,0);
	return 0;
} 

二、邻接矩阵的DFS非递归遍历

/*
Author: luuuuyang
Date: 2018/11/3
Version 1.0
Functions:创建无向网络邻接矩阵即带权无向图+非递归DFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MaxInt 32767//表示无穷大(大于任何权值) 
#define MVnum 100 //Max Vertex Number 
typedef int ElemType;
typedef enum{
    OVERFLOW=-1,
    ERROR=0,
    OK=1
}Status;
typedef struct StackNode{
    ElemType data;
    struct StackNode *next;
}StackNode,*LinkStack;
Status InitStack(LinkStack &S){
    S=NULL;
    return OK;
}
bool StackEmpty(LinkStack S){
    return S?false:true;
}
Status Push(LinkStack &S,ElemType e){
    StackNode *p=new StackNode;
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}
Status Pop(LinkStack &S,ElemType &e){
    if(StackEmpty(S)) return ERROR;
    e=S->data;
    StackNode *p=S;
    S=S->next;
    delete p;
    return OK;
}
typedef char VertexType;//顶点数据类型 
typedef int ArcType;//权值数据类型 
typedef struct{
	VertexType vexs[MVnum];//保存顶点的数组 
	ArcType arcs[MVnum][MVnum];//arcs[i][j]=w 
	int vexnum,arcnum;//顶点数;边数 
}AMGraph;
int LocateVex(AMGraph G,VertexType v){//查找v在G中的数组下标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vexs[i]==v){
			return i;
			break;
		}
}
void CreateUDN(AMGraph &G){
	cout<<"请输入无向网络的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//输入无向网的顶点数和边数
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++) cin>>G.vexs[i];//保存顶点信息 
	for(int i=0;i<G.vexnum;i++)//初始化所有边的权值为无限大 
		for(int j=0;j<G.vexnum;j++)
			G.arcs[i][j]=MaxInt;
	VertexType v1,v2;//定义两点和一边 
	ArcType w;
	cout<<"请输入两顶点以及两顶点的权值:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2>>w;//输入两点和一边 
		int i=LocateVex(G,v1);//查找v1,v2在顶点数组中的下标 
		int j=LocateVex(G,v2);
		G.arcs[i][j]=w;//赋值  i->j=w   j->i=w 
		G.arcs[j][i]=w;
	}
}
bool visit[MVnum];
void DFS_AM(AMGraph G,LinkStack &S,int v){
	Push(S,v);
	visit[v]=1;
	while(!StackEmpty(S)){
		ElemType e;
		Pop(S,e);
		cout<<G.vexs[e];
		for(int w=G.vexnum-1;w>=0;w--)
			if(G.arcs[e][w]!=MaxInt&&!visit[w]){
				Push(S,w);
				visit[w]=1;
			}			
	}
} 
int main(){
	memset(visit,0,sizeof(visit));
	AMGraph G;
	LinkStack S;
	InitStack(S); 
	CreateUDN(G);
	cout<<"邻接矩阵非递归DFS遍历的结果为:"; 
	DFS_AM(G,S,0);
	return 0;
} 

三、邻接矩阵的BFS递归遍历

/*
Author: luuuuyang
Date: 2018/11/4
Version 1.0
Functions:创建无向网络邻接矩阵即带权无向图+递归BFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MaxInt 32767//表示无穷大(大于任何权值) 
#define MVnum 100 //Max Vertex Number 
typedef char VertexType;//顶点数据类型 
typedef int ArcType;//权值数据类型 
typedef struct{
	VertexType vexs[MVnum];//保存顶点的数组 
	ArcType arcs[MVnum][MVnum];//arcs[i][j]=w 
	int vexnum,arcnum;//顶点数;边数 
}AMGraph;
int LocateVex(AMGraph G,VertexType v){//查找v在G中的数组下标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vexs[i]==v){
			return i;
			break;
		}
}
void CreateUDN(AMGraph &G){
	cout<<"请输入无向网络的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//输入无向网的顶点数和边数
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++) cin>>G.vexs[i];//保存顶点信息 
	for(int i=0;i<G.vexnum;i++)//初始化所有边的权值为无限大 
		for(int j=0;j<G.vexnum;j++)
			G.arcs[i][j]=MaxInt;
	VertexType v1,v2;//定义两点和一边 
	ArcType w;
	cout<<"请输入两顶点以及两顶点的权值:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2>>w;//输入两点和一边 
		int i=LocateVex(G,v1);//查找v1,v2在顶点数组中的下标 
		int j=LocateVex(G,v2);
		G.arcs[i][j]=w;//赋值  i->j=w   j->i=w 
		G.arcs[j][i]=w;
	}
}
bool visit[MVnum];
void BFS_AM(AMGraph G,int v){
	bool flag=0;
	if(!visit[v]){
		cout<<G.vexs[v];
		visit[v]=1;
	}
	for(int w=0;w<G.vexnum;w++)
		if(G.arcs[v][w]!=MaxInt&&!visit[w]){
			cout<<G.vexs[w];
			visit[w]=1;
			flag=1;
		}
	if(flag)
		for(int w=0;w<G.vexnum;w++)
			if(G.arcs[v][w]!=MaxInt) BFS_AM(G,w);
} 
int main(){
	memset(visit,0,sizeof(visit));
	AMGraph G;
	CreateUDN(G);
	cout<<"邻接矩阵递归BFS遍历的结果为:"; 
	BFS_AM(G,0);
	return 0;
} 

四、邻接矩阵的BFS非递归遍历

/*
Author: luuuuyang
Date: 2018/11/3
Version 1.0
Functions:创建无向网络邻接矩阵即带权无向图+非递归BFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MaxInt 32767//表示无穷大(大于任何权值) 
#define MVnum 100 //Max Vertex Number
typedef int ElemType;
typedef enum{
    OVERFLOW=-1,
    ERROR=0,
    OK=1
}Status;
typedef struct Qnode{
    ElemType data;
    struct Qnode *next;
}Qnode,*QueuePtr;
typedef struct{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
Status InitQueue(LinkQueue &Q){
    Q.front=Q.rear=new Qnode;
    Q.front->next=NULL;
    return OK;
}
Status QueueEmpty(LinkQueue Q){
    return Q.front==Q.rear?OK:ERROR;
}
Status EnQueue(LinkQueue &Q,ElemType e){
    Qnode *p=new Qnode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}
Status DeQueue(LinkQueue &Q,ElemType &e){
    if(Q.front==Q.rear) return ERROR;
    Qnode *p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p) Q.rear=Q.front;
    delete p;
    return OK;
} 
typedef char VertexType;//顶点数据类型 
typedef int ArcType;//权值数据类型 
typedef struct{
	VertexType vexs[MVnum];//保存顶点的数组 
	ArcType arcs[MVnum][MVnum];//arcs[i][j]=w 
	int vexnum,arcnum;//顶点数;边数 
}AMGraph;
int LocateVex(AMGraph G,VertexType v){//查找v在G中的数组下标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vexs[i]==v){
			return i;
			break;
		}
}
void CreateUDN(AMGraph &G){
	cout<<"请输入无向网络的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//输入无向网的顶点数和边数
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++) cin>>G.vexs[i];//保存顶点信息 
	for(int i=0;i<G.vexnum;i++)//初始化所有边的权值为无限大 
		for(int j=0;j<G.vexnum;j++)
			G.arcs[i][j]=MaxInt;
	VertexType v1,v2;//定义两点和一边 
	ArcType w;
	cout<<"请输入两顶点以及两顶点的权值:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2>>w;//输入两点和一边 
		int i=LocateVex(G,v1);//查找v1,v2在顶点数组中的下标 
		int j=LocateVex(G,v2);
		G.arcs[i][j]=w;//赋值  i->j=w   j->i=w 
		G.arcs[j][i]=w;
	}
}
bool visit[MVnum];
void BFS_AM(AMGraph G,LinkQueue &Q,int v){
	EnQueue(Q,v);
	visit[v]=1;
	while(!QueueEmpty(Q)){
		ElemType e;
		DeQueue(Q,e);
		cout<<G.vexs[e];
		for(int w=0;w<G.vexnum;w++)
			if(G.arcs[e][w]!=MaxInt&&!visit[w]){
				EnQueue(Q,w);
				visit[w]=1;
			} 
	}
} 
int main(){
	memset(visit,0,sizeof(visit));
	LinkQueue Q;
	InitQueue(Q);
	AMGraph G;
	CreateUDN(G);
	cout<<"邻接矩阵非递归BFS遍历的结果为:"; 
	DFS_AM(G,Q,0);
	return 0;
} 

五、邻接表的DFS递归遍历

/*
Author: luuuuyang
Date: 2018/11/4
Version 1.0
Functions:创建无向图邻接表+递归DFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MVnum 100
typedef char VertexType;
typedef struct ArcNode{//边结点 
	int adjvex;//邻接点域 
	struct ArcNode *nextarc;//链域
	//OtherInfo info//数据域 
}ArcNode;
typedef struct VNode{//表头结点 
	VertexType data;//数据域 
	ArcNode *firstarc;//链域 
}VNode,AdjList[MVnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
int LocateVex(ALGraph G,VertexType v){//查找顶点坐标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vertices[i].data==v) return i;
}
bool a[MVnum];//在构建邻接表时判断该点是否属于第一次插上边结点 
void CreateUDG(ALGraph &G){
	cout<<"请输入无向图的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//确定顶点数和边数 
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++){ 
		cin>>G.vertices[i].data;//保存顶点 
		G.vertices[i].firstarc=NULL;//初始化顶点的第一个邻接点为空 
	}
	VertexType v1,v2;//定义两个顶点 
	cout<<"请输入顶点连接信息:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		int i=LocateVex(G,v1);
		int j=LocateVex(G,v2);
		ArcNode *p1=new ArcNode;//创建一个新的边结点插入到表头头部
		ArcNode *p2=new ArcNode;
		ArcNode *t1,*t2;//用于链表尾插法的中间变量 
		p1->adjvex=j;//i->j中把j保存起来
		p1->nextarc=NULL; 
		p2->adjvex=i;//j->i中把i保存起来 
		p2->nextarc=NULL;
		if(!a[i]){//如果该点第一次插入边结点 
			G.vertices[i].firstarc=p1;//表头结点后面直接插入该点 
			a[i]=1; 
		}
		else{ //否则 
			t1=G.vertices[i].firstarc;//先让中间变量访问到第一个边结点 
			while(t1->nextarc!=NULL){//一直往后面找,直到最后一个节点停止 
				t1=t1->nextarc;
			}
			t1->nextarc=p1;//最后一个节点的指针域指向新结点 
		}
		if(!a[j]){//第二个点同理 
			G.vertices[j].firstarc=p2;
			a[j]=1;
		}
		else{
			t2=G.vertices[j].firstarc;
			while(t2->nextarc!=NULL){
				t2=t2->nextarc;
			}
			t2->nextarc=p2;
		}	
	}
}
bool visit[MVnum];
void DFS_AL(ALGraph G,int v){	
	cout<<v;
	visit[v]=1;
	ArcNode *p=G.vertices[v].firstarc;
	while(p!=NULL){
		int w=p->adjvex;
		if(!visit[w]) DFS_AL(G,w);
		p=p->nextarc;
	}
} 
int main(){
	memset(visit,0,sizeof(visit));
	memset(a,0,sizeof(a));
	ALGraph G;
	CreateUDG(G);
	cout<<"邻接表递归DFS遍历的结果为:"; 
	DFS_AL(G,0); 
	return 0;
}

六、邻接表的DFS非递归遍历

/*
Author: luuuuyang
Date: 2018/11/4
Version 1.0
Functions:创建无向图邻接表+非递归DFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MVnum 100
typedef int ElemType;
typedef enum{
    OVERFLOW=-1,
    ERROR=0,
    OK=1
}Status;
typedef struct StackNode{
    ElemType data;
    struct StackNode *next;
}StackNode,*LinkStack;
Status InitStack(LinkStack &S){
    S=NULL;
    return OK;
}
bool StackEmpty(LinkStack S){
    return S?false:true;
}
Status Push(LinkStack &S,ElemType e){
    StackNode *p=new StackNode;
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}
Status Pop(LinkStack &S,ElemType &e){
    if(StackEmpty(S)) return ERROR;
    e=S->data;
    StackNode *p=S;
    S=S->next;
    delete p;
    return OK;
}
typedef char VertexType;
typedef struct ArcNode{//边结点 
	int adjvex;//邻接点域 
	struct ArcNode *nextarc;//链域
	//OtherInfo info//数据域 
}ArcNode;
typedef struct VNode{//表头结点 
	VertexType data;//数据域 
	ArcNode *firstarc;//链域 
}VNode,AdjList[MVnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
int LocateVex(ALGraph G,VertexType v){//查找顶点坐标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vertices[i].data==v) return i;
}
void CreateUDG(ALGraph &G){
	cout<<"请输入无向图的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//确定顶点数和边数 
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++){ 
		cin>>G.vertices[i].data;//保存顶点 
		G.vertices[i].firstarc=NULL;//初始化顶点的第一个邻接点为空 
	}
	VertexType v1,v2;//定义两个顶点 
	cout<<"请输入顶点连接信息:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		int i=LocateVex(G,v1);
		int j=LocateVex(G,v2);
		ArcNode *p1=new ArcNode;
		p1->adjvex=j;
		p1->nextarc=G.vertices[i].firstarc;
		G.vertices[i].firstarc=p1;
		ArcNode *p2=new ArcNode;
		p2->adjvex=i;
		p2->nextarc=G.vertices[j].firstarc;
		G.vertices[j].firstarc=p2;
	}
}
bool visit[MVnum];
void DFS_AL(ALGraph G,LinkStack &S,int v){
	Push(S,v);
	visit[v]=1;
	while(!StackEmpty(S)){
		ElemType e;
		Pop(S,e);
		cout<<e;
		ArcNode *p=G.vertices[e].firstarc;
		while(p!=NULL){
			if(!visit[p->adjvex]){
				Push(S,p->adjvex);
				visit[p->adjvex]=1;	
			} 
			p=p->nextarc;
		}
	}	
} 
int main(){
	memset(visit,0,sizeof(visit));
	ALGraph G;
	LinkStack S;
	InitStack(S);
 	CreateUDG(G);
	cout<<"邻接表非递归DFS遍历的结果为:"; 
	DFS_AL(G,S,0); 
	return 0;
}

七、邻接表的BFS递归遍历

/*
Author: luuuuyang
Date: 2018/11/4
Version 1.0
Functions:创建无向图邻接表+递归BFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MVnum 100
typedef char VertexType;
typedef struct ArcNode{//边结点 
	int adjvex;//邻接点域 
	struct ArcNode *nextarc;//链域 
	//OtherInfo info//数据域 
}ArcNode;
typedef struct VNode{//表头结点 
	VertexType data;//数据域 
	ArcNode *firstarc;//链域 
}VNode,AdjList[MVnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
int LocateVex(ALGraph G,VertexType v){//查找顶点坐标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vertices[i].data==v) return i;
}
bool a[MVnum];//在构建邻接表时判断该点是否属于第一次插上边结点 
void CreateUDG(ALGraph &G){
	cout<<"请输入无向图的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//确定顶点数和边数 
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++){ 
		cin>>G.vertices[i].data;//保存顶点 
		G.vertices[i].firstarc=NULL;//初始化顶点的第一个邻接点为空 
	}
	VertexType v1,v2;//定义两个顶点 
	cout<<"请输入顶点连接信息:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		int i=LocateVex(G,v1);
		int j=LocateVex(G,v2);
		ArcNode *p1=new ArcNode;//创建一个新的边结点插入到表头头部
		ArcNode *p2=new ArcNode;
		ArcNode *t1,*t2;//用于链表尾插法的中间变量 
		p1->adjvex=j;//i->j中把j保存起来
		p1->nextarc=NULL; 
		p2->adjvex=i;//j->i中把i保存起来 
		p2->nextarc=NULL;
		if(!a[i]){//如果该点第一次插入边结点 
			G.vertices[i].firstarc=p1;//表头结点后面直接插入该点 
			a[i]=1; 
		}
		else{ //否则 
			t1=G.vertices[i].firstarc;//先让中间变量访问到第一个边结点 
			while(t1->nextarc!=NULL){//一直往后面找,直到最后一个节点停止 
				t1=t1->nextarc;
			}
			t1->nextarc=p1;//最后一个节点的指针域指向新结点 
		}
		if(!a[j]){//第二个点同理 
			G.vertices[j].firstarc=p2;
			a[j]=1;
		}
		else{
			t2=G.vertices[j].firstarc;
			while(t2->nextarc!=NULL){
				t2=t2->nextarc;
			}
			t2->nextarc=p2;
		}	
	}
}
bool visit[MVnum];
void BFS_AL(ALGraph G,int v){
	if(!visit[v]){
		cout<<v;
		visit[v]=1;	
	}	
	ArcNode *p=G.vertices[v].firstarc;
	while(p!=NULL){
		if(!visit[p->adjvex]){
			cout<<p->adjvex;
			visit[p->adjvex]=1;
		} 
		p=p->nextarc;
	}
	p=G.vertices[v].firstarc;
	while(p!=NULL){
		BFS_AL(G,p->adjvex);
		p=p->nextarc;
	} 
} 
int main(){
	memset(visit,0,sizeof(visit));
	memset(a,0,sizeof(a));
	ALGraph G;
	CreateUDG(G);
	cout<<"邻接表递归BFS遍历的结果为:"; 
	BFS_AL(G,0); 
	return 0;
}

八、邻接表的BFS非递归遍历

/*
Author: luuuuyang
Date: 2018/11/4
Version 1.0
Functions:创建无向图邻接表+非递归BFS遍历 
*/
#include<iostream>
#include<cstring>
using namespace std;
#define MVnum 100
typedef int ElemType;
typedef enum{
    OVERFLOW=-1,
    ERROR=0,
    OK=1
}Status;
typedef struct Qnode{
    ElemType data;
    struct Qnode *next;
}Qnode,*QueuePtr;
typedef struct{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
Status InitQueue(LinkQueue &Q){
    Q.front=Q.rear=new Qnode;
    Q.front->next=NULL;
    return OK;
}
Status QueueEmpty(LinkQueue Q){
    return Q.front==Q.rear?OK:ERROR;
}
Status EnQueue(LinkQueue &Q,ElemType e){
    Qnode *p=new Qnode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}
Status DeQueue(LinkQueue &Q,ElemType &e){
    if(Q.front==Q.rear) return ERROR;
    Qnode *p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p) Q.rear=Q.front;
    delete p;
    return OK;
} 
typedef char VertexType;
typedef struct ArcNode{//边结点 
	int adjvex;//邻接点域 
	struct ArcNode *nextarc;//链域 
	//OtherInfo info//数据域 
}ArcNode;
typedef struct VNode{//表头结点 
	VertexType data;//数据域 
	ArcNode *firstarc;//链域 
}VNode,AdjList[MVnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
int LocateVex(ALGraph G,VertexType v){//查找顶点坐标 
	for(int i=0;i<G.vexnum;i++)
		if(G.vertices[i].data==v) return i;
}
bool a[MVnum];//在构建邻接表时判断该点是否属于第一次插上边结点 
void CreateUDG(ALGraph &G){
	cout<<"请输入无向图的顶点数和边数:";
	cin>>G.vexnum>>G.arcnum;//确定顶点数和边数 
	cout<<"请输入这"<<G.vexnum<<"顶点的名称:";
	for(int i=0;i<G.vexnum;i++){ 
		cin>>G.vertices[i].data;//保存顶点 
		G.vertices[i].firstarc=NULL;//初始化顶点的第一个邻接点为空 
	}
	VertexType v1,v2;//定义两个顶点 
	cout<<"请输入顶点连接信息:"<<endl;
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		int i=LocateVex(G,v1);
		int j=LocateVex(G,v2);
		ArcNode *p1=new ArcNode;//创建一个新的边结点插入到表头头部
		ArcNode *p2=new ArcNode;
		ArcNode *t1,*t2;//用于链表尾插法的中间变量 
		p1->adjvex=j;//i->j中把j保存起来
		p1->nextarc=NULL; 
		p2->adjvex=i;//j->i中把i保存起来 
		p2->nextarc=NULL;
		if(!a[i]){//如果该点第一次插入边结点 
			G.vertices[i].firstarc=p1;//表头结点后面直接插入该点 
			a[i]=1; 
		}
		else{ //否则 
			t1=G.vertices[i].firstarc;//先让中间变量访问到第一个边结点 
			while(t1->nextarc!=NULL){//一直往后面找,直到最后一个节点停止 
				t1=t1->nextarc;
			}
			t1->nextarc=p1;//最后一个节点的指针域指向新结点 
		}
		if(!a[j]){//第二个点同理 
			G.vertices[j].firstarc=p2;
			a[j]=1;
		}
		else{
			t2=G.vertices[j].firstarc;
			while(t2->nextarc!=NULL){
				t2=t2->nextarc;
			}
			t2->nextarc=p2;
		}	
	}
}
bool visit[MVnum];
void BFS_AL(ALGraph G,LinkQueue &Q,int v){
	EnQueue(Q,v);
	visit[v]=1;
	while(!QueueEmpty(Q)){
		ElemType e;
		DeQueue(Q,e);
		cout<<e;
		ArcNode *p=G.vertices[e].firstarc;
		while(p!=NULL){
			if(!visit[p->adjvex]){
				EnQueue(Q,p->adjvex);
				visit[p->adjvex]=1;
			}
			p=p->nextarc; 
		} 
	}
} 
int main(){
	memset(visit,0,sizeof(visit));
	memset(a,0,sizeof(a));
	LinkQueue Q;
	InitQueue(Q);
	ALGraph G;
	CreateUDG(G);
	cout<<"邻接表非递归BFS遍历的结果为:"; 
	BFS_AL(G,Q,0); 
	return 0;
}

 

展开阅读全文

没有更多推荐了,返回首页