详解邻接矩阵和邻接表分别实现DFS和BFS——C++

题目：

采用邻接矩阵和邻接表存储结构来建立有向图或无向图，实现深度优先或广度优先的遍历算法。

测试图：

代码1：

/*采用邻接矩阵存储图*/ 
#include<iostream>
#include<cstring>
#include<queue> 
#include<map> 
using namespace std;

const int INF=0x3f3f3f3f;
const int MVNum=100;			//最大顶点数 
int visited[MVNum];				//访问数组 
map<char ,int> mp;
	
typedef struct{					//邻接矩阵存储无向图 
	char vexs[MVNum];			//假设顶点数据类型为字符型 
	int arcs[MVNum][MVNum];		//假设边的权值类型为整形
	int vexnum,arcnum;			//图的点数和边数 
}Graph;

void CreateGraph(Graph &G){
	int w;
	char v1,v2;
	cout<<"输入图的顶点数和边数："<<endl; 
	cin>>G.vexnum>>G.arcnum;
	cout<<"依次输入"<<G.vexnum<<"个顶点："<<endl; 
	for(int i=0;i<G.vexnum;++i){
		cin>>G.vexs[i];
		mp[G.vexs[i]]=i;		//顶点在图中的位置即为顶点的输入次序
	}
	memset(G.arcs,INF,sizeof(G.arcs));	//初始化邻接矩阵 
	cout<<"依次输入"<<G.arcnum<<"条边的两个顶点和权值"<<endl; 
	for(int i=0;i<G.arcnum;++i){
		cin>>v1>>v2>>w;
		G.arcs[mp[v1]][mp[v2]]=w;
		G.arcs[mp[v2]][mp[v1]]=w;
	} 
}

void DFS(Graph G,int v){
	cout<<G.vexs[v];
	visited[v]=1;
	for(int w=0;w<G.vexnum;++w){
		if((!visited[w])&&(G.arcs[v][w]!=INF)){
			DFS(G,w);
		}
	}
}

void BFS(Graph G,int v){
	cout<<G.vexs[v];
	visited[v]=1;
	queue<int> Q; 	//STL
	Q.push(v);
	while(!Q.empty()){
		int u=Q.front();
		Q.pop();
		for(int w=0;w<G.vexnum;++w){
			if((!visited[w])&&(G.arcs[u][w]!=INF)){
				cout<<G.vexs[w];
				visited[w]=1;
				Q.push(w);
			}
		}
	} 
	
}

int main(){
	Graph G;
	CreateGraph(G);
	cout<<"DFS:"; 
	DFS(G,0);		//从第0个顶点开始DFS
	memset(visited,0,sizeof(visited));	//重新初始化visited数组
	cout<<endl<<"BFS:"; 
	BFS(G,0);		//从第0个顶点开始BFS 
	return 0;
}

代码1运行结果：

代码2：

/*采用邻接表存储图*/ 
#include<iostream>
#include<queue> 
#include<map>
#include<cstring>
using namespace std;

const int MVNum=100;		//最大顶点数
map<char,int> mp;			//使用map来存储顶点对应邻接表中的位置 
int visited[MVNum];

typedef struct ArcNode{		//边结点 
	int adjvex;
	struct ArcNode *nextarc; 
}ArcNode;

typedef struct VNode{		//顶点信息 
	char data;
	ArcNode *firstarc;
}VNode,AdjList[MVNum];

typedef struct{				//邻接表 
	AdjList vertices;
	int vexnum,arcnum; 
}Graph;

void CreateGraph(Graph &G){
	char v1,v2;
	cout<<"输入图的顶点数和边数："<<endl; 
	cin>>G.vexnum>>G.arcnum;
	cout<<"依次输入"<<G.vexnum<<"个顶点："<<endl; 
	for(int i=0;i<G.vexnum;++i){
		cin>>G.vertices[i].data;
		G.vertices[i].firstarc=NULL;
		mp[G.vertices[i].data]=i;
	}
	cout<<"依次输入"<<G.arcnum<<"条边的两个顶点"<<endl; 
	for(int k=0;k<G.arcnum;++k){
		cin>>v1>>v2;
		int i=mp[v1];
		int j=mp[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;
	}
}

void DFS(Graph G,int v){
	cout<<G.vertices[v].data;
	visited[v]=1;
	ArcNode *p=G.vertices[v].firstarc;
	while(p!=NULL){
		int w=p->adjvex;
		if(!visited[w]) DFS(G,w);
		p=p->nextarc;
	}
}

void BFS(Graph G,int v){
	cout<<G.vertices[v].data;
	visited[v]=1;
	queue<int> Q;			//队列 
	Q.push(v);
	while(!Q.empty()){
		int w=Q.front();
		Q.pop();
		ArcNode *p=G.vertices[w].firstarc;
		while(p!=NULL){
			if(!visited[p->adjvex]){
				cout<<G.vertices[p->adjvex].data;
				visited[p->adjvex]=1;
				Q.push(p->adjvex);
			}
			p=p->nextarc;	//注意 
		}
	}
}

int main(){
	Graph G;
	CreateGraph(G);
	cout<<"DFS:"; 
	DFS(G,0);		//从第0个顶点开始DFS
	memset(visited,0,sizeof(visited));	//重新初始化visited数组
	cout<<endl<<"BFS:"; 
	BFS(G,0);		//从第0个顶点开始BFS 
	return 0;
}

代码2运行结果：