邻接矩阵和邻接表的深度优先遍历

我们既然已经可以打印邻接表和邻接矩阵，下面我们可以对邻接矩阵和邻接表进行深度优先遍历

这是邻接表的深度优先遍历

#include<stdio.h>
#include<iostream>
using namespace std;

//构建无向网
#define MVNum 100//设置最大顶点数为100自定义宏
#define INFINITY 35575//定义宏数字35575代表无穷大
//bool visted[MVNum];
typedef char Vertextype;
typedef int edge;
//无向网图的建立
typedef struct
{
	Vertextype vex[MVNum];//一维数组储存顶点，依次存储每个顶点构建邻接矩阵
	edge arcs[MVNum][MVNum];//二维数组邻接矩阵
	int vexnum,arcnum;

}AMGraph;//零阶矩阵的存储表示
int Localvex(Vertextype u, AMGraph G)
{
	cout << "输入顶点";
	cin >> u;
	int i;
	for (i = 0; i < G.vexnum; i++)
	{
		if (u == G.vex[i])
		{
			
			return i;
		}
	return -1;
	}
}

void CreatUDN(AMGraph &G)//表示通过G带回返回值
{
	cout << "请输入顶点数和边数 :";
	cin >> G.vexnum >> G.arcnum;
	int i,j,k,w;
	Vertextype v1, v2;
	cout << "存入顶点";
	for(i=0;i<G.vexnum;i++)
	{
	cin>>G.vex[i];	
	}
	for(i=0;i<G.vexnum;i++)
	{
		for (j = 0; j < G.vexnum; j++)
		{
			G.arcs[i][j] = 0;
		}
	}//初始化各顶点
	//for (int i = 0; i < G.vexnum; i++)
	//{
	//	printf("\n");
	//	for (int j = 0; j < G.vexnum; j++)
	//	{
	//		//cout << G.arcs[i][j];
	//		printf("%d\t", G.arcs[i][j]);
	//	测试是否初始化成功	
	//	}
	//}
	for (k = 0;k<G.arcnum;k++)
	{
		int g_i, g_j;
		cout << "输入参数：";
		cin >> g_i >>g_j ;
		//cin >> w;
		G.arcs[g_i][g_j] = 1;//由于g_i和g_j从零开始所以记得对应位置-1
		G.arcs[g_j][g_i] = G.arcs[g_i][g_j];
		//cout << "输入顶点和权值";
		//cin >> v1 >> v2>>w;
		//i = Localvex(v1, G);//调用函数返回v1在表中位置
		//j = Localvex(v2, G);
		//G.arcs[i][j] = w;
		//G.arcs[j][i] = w;//无向网图为对称矩阵
			
	}

	//构建邻接矩阵矩阵


}
void Print(AMGraph &G)
{
	for (int j = 0; j < G.vexnum; j++)
	{
		printf("\n");
		for (int i = 0; i < G.vexnum; i++)
		{
			//cout << G.arcs[i][j];
			printf("%d\t", G.arcs[i][j]);
			/*if (G.arcs[i][j] != INFINITY)
			{
				cout << G.arcs[i][j];
			}
			else
			{
				cout << "#" << " ";
			}*/
		}
		cout << endl;
	}

}
void DFS(AMGraph G,int i,int*visited)
{
	int j;
	cout<<G.vex[i];
	visited[i] = 1;
	for (j = 0; j < G.vexnum; j++)
	{
		if ((G.arcs[i][j] != 0) && (visited[j]!=1))//判断点位是否被访问和边长
		{
			DFS(G,j,visited);//递归函数
		}
	}//深度优先
		
		
			

		 

}

int main(void)
{
	AMGraph TEST ;
	CreatUDN(TEST);
	Print(TEST);
	int visited[MVNum] = { 0 };
	DFS(TEST,0,visited);//abcde 五个点，分别对应0-4选择位置开始访问
	return 0;
}

我们以一个图为列子

 这是对邻接矩阵的深度优先遍历

以a b c d e对应图中v1 v2 v3 v4 v5

下面展示运行结果

 

下面我们再来看看邻接表

 

#include<stdio.h>
#include<iostream>
#include<malloc.h>
using namespace std;
#define MVNUM 100
typedef int edgetype;
typedef char vextype;
typedef struct Edgenode
{
	edgetype adjvex;//邻接域下标
	struct Edgenode *next;
	//edgetype weight;//若有权值加上该条

}Edgnode;//邻接域
typedef struct Headvex
{
	Edgnode * firstnode;
	vextype data;

}Hedavex, ahead[MVNUM];//头节点
typedef struct
{
	ahead head;//储存头节点的数组
	int vexnum, arcnum;
}Headlist;
void creatlist(Headlist*G)
{
	int i,j,k,v,a;

	Edgnode *e;
	
	cout << "输入顶点数和边数：";
	cin >> G->vexnum >> G->arcnum;
	cout << "存入顶点:";
	for (v = 0; v < G->vexnum; v++)
	{
		cin >> G->head[v].data;
		G->head[v].firstnode = NULL;
	}//初始化邻接表
	for (k = 0; k < G->arcnum; k++)
	{
		int listnum1, listnum2;//输入顶点表序号位置i,listnum2代表邻接的下标
		cout << "输入顶点表位置和下标:";
		cin >> listnum1 >> listnum2;
		//cin>>w;
		e = (Edgenode*)malloc(sizeof(Edgenode));
		e->adjvex = listnum2 ;
		//e->weight = w;
		e->next = G->head[listnum1].firstnode;
		G->head[listnum1].firstnode = e;
		e = (Edgenode*)malloc(sizeof(Edgenode));//无向网没有出入度，故在listnum2连接listnum1
		e->adjvex = listnum1;
		e->next = G->head[listnum2].firstnode;
		G->head[listnum2].firstnode = e;

	}

}


void DFS(Headlist*G,int *visited,int v)
{
	int i;
	cout << G->head[v].data;
	visited[v] = 1;
	Edgenode* p;
	p = (Edgenode*)malloc(sizeof(Edgenode));
	p = G->head[v].firstnode;
	/*for (i = 0; i < G->vexnum; i++)
	{
		if (visited[i] != 1)
		{
			DFS(G, visited, i);
		}

	}*/
	while (p != NULL)
	{
		if (visited[p->adjvex] != 1)
		{
			DFS(G, visited, p->adjvex);
		}
		p = p->next;
	}//对深度优先遍历递归函数
	

	
	

		
}
//void DFST(Headlist *G,int*visited)
//{
//	int i;
//	for (i = 0; i < G->vexnum; i++)
//	{
//		visited[i] = 0;
//	}
//	for (i = 0;i<G->vexnum; i++)
//	{
//		if (visited[i]!=1)
//		{
//			DFS(G, visited,i);
//		}
//		
//	}

//}
void printlist(Headlist*G)
{
	int i, j;
	Edgenode* q;
	
	for (i = 0; i < G->vexnum; i++)
	{
		printf("%d->", i);
		q = G->head[i].firstnode;
		/*for (q = G->head[i].firstnode; q != NULL; q = q->next)
		{
			printf("%d->", q->adjvex);
		}
		printf("\n");*/
		if (q != NULL)
		{
			while (q != NULL)
			{
				printf("%d->",q->adjvex);
				q = q->next;
				if (q == NULL)
				{
					printf("^");
				}
			}

			printf("\n");

		}
	}

}//打印邻接表


int main(void)
{
	Headlist* TEST=(Headlist*)malloc(sizeof(Headlist));// 初始化结构体内存
	creatlist(TEST);
	printlist(TEST);
	int visited[MVNUM] = { 0 };
	cout << "深度优先遍历：";
	DFS(TEST, visited, 0);
	cout << endl;
	//DFST(TEST, visited);
	return 0;
}

依旧以这张图为列子；我们打印邻接表并进行深度优先遍历