（数据结构） 无向图的深度优先遍历

• 无向图的深度优先遍历

1.定义图的邻接矩阵存储表示（AMGraph）

2.采用邻接矩阵表示法创建无向图（CreateUDG）

3.输出所建图的邻接矩阵（PrintAMGraph）

4.输出所建图的深度优先遍历序列（DFSTraverse）

例如：

5 6        //顶点数和边数的输入

1 2 3 4 5    //顶点信息的输入

1 2        //边信息的输入

1 4

2 3

3 4

2 5

3 5

0 1 0 1 0    //邻接矩阵的输出

1 0 1 0 1

0 1 0 1 1

1 0 1 0 0

0 1 1 0 0

1 2 3 4 5   //深度优先遍历序列

 

 

#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define MaxInt 32767   //表示极大值，即∞
#define MVNum 100      //最大顶点数
typedef int VerTexType;//假设顶点的数据类型为整型
typedef int ArcType;   //假设边的权值类型为整型
typedef struct
{
	VerTexType vexs[MVNum];     //顶点表
	ArcType arcs[MVNum][MVNum]; //邻接矩阵
	int vexnum,arcnum;          //图的当前点数和边数
}AMGraph;

int LocateVex(AMGraph G,VerTexType v) //查询顶点v在图G中的下标位置
{
	for(int i=0;i<G.vexnum;i++){
		if(v==G.vexs[i]){
			return i;
		}
	}
}

//此处定义无向图的创建
int CreateUDN(AMGraph &G){
	int v1,v2; 
	//采用邻接矩阵表示法，创建无向网
	cin>>G.vexnum>>G.arcnum;//输入顶点数，总边数
	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]=0; //初始化邻接矩阵，权值设置为0
	} 
	
	}
	
	for(int k=0;k<G.arcnum;k++){
		cin>>v1>>v2;           //输入一条边依附的顶点及权值 
		int i=LocateVex(G,v1);int j=LocateVex(G,v2);
		G.arcs[i][j]=1;
		G.arcs[j][i]=G.arcs[i][j];
		
	}
	return OK;
} 
//此处定义无向图的邻接矩阵的输出
int PrintAMGraph(AMGraph &G){
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			
			cout<<G.arcs[i][j];
			if(j==G.vexnum-1){
				cout<<endl;
			}
		}
		
	}
}
//--------深度优先搜索遍历邻接矩阵--------// 
bool visited[MVNum];
void DFS_AM(AMGraph G,int v){
	cout<<G.vexs[v];visited[v]=true;
	for(int w=0;w<G.vexnum;w++){
		if((G.arcs[v][w]!=0)&&(!visited[w])){
			DFS_AM(G,w);
		}
	}
} 
int main()
{
	AMGraph G;
	int v;
//调用利用邻接矩阵创建无向图的函数CreateUDG
CreateUDN(G);
//调用输出邻接矩阵的函数PrintAMGraph
PrintAMGraph(G);
cout<<"请输入遍历开始的节点"<<endl;
cin>>v;
//调用深度优先搜索遍历函数 DFS_AM
DFS_AM(G,v);
	return 0;
}