【算法——02】图的遍历——BFS广度优先搜索、DFS深度优先搜索

最新推荐文章于 2022-05-05 10:22:54 发布

洞之蝉

最新推荐文章于 2022-05-05 10:22:54 发布

阅读量760

点赞数

本文链接：https://blog.csdn.net/muyimo/article/details/38433797

版权

1.图的创建（邻接表）

可以采用邻接矩阵、邻接表来表示。邻接矩阵比较适合稠密图，对于稀疏图用邻接表来表示。

邻接表是图的一种链式结构。图中每个顶点建一个单链表，单链表的节点表示依附于顶点的各边，节点由3个域组成。

1）.单链表节点：由3个域组成

图上有几个顶点，就有几个单链表节点

邻接点域：adjvex 表示节点的邻接点在图中的位置，如第0、1、2、3、4个节点。节点1的adjvex就是0，v0所在的节点么。

链域：nextarc 表示下一条边的节点，1的nextarc就是2

数据域：info 表示节点信息，如权值什么的。

2）头结点

每个单链表设置一个表头节点，头结点包括数据域和链域。链域主要指向第一个邻接点。

//图的邻接表节点，3个域组成
struct EdgeNode{
	int adjvex;//邻接点域
	EdgeNode* nextArc;//链域
	int *data;//权值
};

//头结点存放顶点信息
typedef struct VNode{
	char info;//顶点信息
	EdgeNode* firstArc;//表头的边指针
}AdjList[MAX_VEX_NUM];//定义邻接表


//图结构
struct ALGraph{
	AdjList vertices;//邻接表
	int VexNum;
	int ArcNum;//图的当前顶点数和弧数
};

2.BFS广度优先搜索

广度优先遍历就好像二叉树的层序遍历，先访问离起始点近的节点，不断的插入队列。要设置标志数组，用来存放已经访问的节点。

实现广度优先搜索，也要遵守三个规则：
(1) 访问下一个邻接点，这个顶点必须是当前顶点的邻接点，标记它，并把它插入到队列中。
(2) 如果这个节点的邻接点已经访问完，那么从队列头取一个顶点，并使其成为当前顶点。
(3) 如果因为队列为空而不能执行规则2，则搜索结束。

 void BFS(ALGraph G,int k)
 { 
	// 以vk为源点对用邻接表表示的图G进行广度优先搜索
	visited[k] = 1;
	cout << G.vertices[k].info << " ";
	q.push(k);//vk已访问，将其序号放入队列
	while(!q.empty())
	{
		int i = q.front();
		q.pop();//队头元素出队并置为vi,vi出队 
		EdgeNode *edge = G.vertices[i].firstArc;//取出vI的边表头指针
			while(edge)//依次搜索vi的邻接点vj 
				{
					if(!visited[edge->adjvex])
					{
						visited[edge->adjvex] = 1;
						cout << G.vertices[edge->adjvex].info << " ";
						q.push(edge->adjvex);//入队
					}
					edge = edge->nextArc;//找edge的下一邻接点 
				}
			} 
 }

void BFSTraverseN(ALGraph G)//广度优先遍历节点
{
	 for(int i = 0;i<G.VexNum;i++)//存放顶点的访问数组初始化
		 visited[i] = 0;
	  for(int i = 0;i<G.VexNum;i++)//依次访问节点
		 if(!visited[i])
			 BFS(G,i);
}

3.深度优先搜索DFS

深度优先搜索就像二叉树的先序遍历，假如图的顶点没有被访问，深度优先搜索可以从此节点出发依次访问节点直到不能再访问，然后再选一个。

可以采用递归或栈结构来实现，此处采用递归，

为了实现深度优先搜索，首先选择一个起始顶点并需要遵守三个规则：
(1) 如果可能，访问一个邻接的未访问顶点，标记它。
(2) 然后如果此节点有邻接点，并且未被访问，则递归DFS此表头节点

(3)之后指向该节点邻接表头结点的别的邻接点

void DFS(ALGraph G,int k)
{
	//以vi为出发点对邻接表表示的图G进行深度优先搜索
	visited[k] = 1;
	cout << G.vertices[k].info << " ";
	EdgeNode *edge = G.vertices[k].firstArc;//取出vI的边表头指针
	while(edge)
	{
		if(!visited[edge->adjvex])
			DFS(G,edge->adjvex);
		edge = edge->nextArc;
	}
}
void DFSTraverseN(ALGraph G)//广度优先遍历节点
{
	 for(int i = 0;i<G.VexNum;i++)//存放顶点的访问数组初始化
		 visited[i] = 0;
	  for(int i = 0;i<G.VexNum;i++)//依次访问节点
		 if(!visited[i])
			 DFS(G,i);
}

BFS和DFS实现：

#include<iostream>
#include<queue>
using namespace std;

#define MAX_VEX_NUM 20
int visited[MAX_VEX_NUM];//设置标志数组
queue<int> q;//新建队列存放顶点



//图的邻接表节点，3个域组成
struct EdgeNode{
	int adjvex;//邻接点域
	EdgeNode* nextArc;//链域
	int *data;//权值
};

//头结点存放顶点信息
typedef struct VNode{
	char info;//顶点信息
	EdgeNode* firstArc;//表头的边指针
}AdjList[MAX_VEX_NUM];//定义邻接表


//图结构
struct ALGraph{
	AdjList vertices;//邻接表
	int VexNum;
	int ArcNum;//图的当前顶点数和弧数
};



 ALGraph Graph;//声明一个无向图的邻接表类型

 //查找顶点是顶点集第几个
 int LocateVex(ALGraph Graph,char Vex)
 {
	
	for(int i = 0; i < Graph.VexNum; i++)
		{
			if(Vex == Graph.vertices[i].info)//如果第i个节点是顶点集里的节点
			return i;
	    }
	return -1;
 }


//创建无向图
 void CreateUDG(ALGraph &G)
 {
	
	cout << "请输入图的顶点数和弧数:"<<endl;
	cin >> G.VexNum >> G.ArcNum;

	char v1 ='A',v2 ='B';//弧依附的顶点
	int v1Locate ,v2Locate ;
	
	
	cout<<"输入顶点的值"<<endl; 

	for(int i = 0;i<G.VexNum;i++)
		{
			cin >> G.vertices[i].info;//初始化图的各个顶点
			G.vertices[i].firstArc = NULL;
		}

	//创建邻接链表
	
	for(int j = 0;j < G.ArcNum;j++ )
		{
			cout<<"输入边信息：由两个顶点确定："<<endl;
			cin >> v1 >> v2;//读入边<vi,v2>对应的序号

			v1Locate= LocateVex(G,v1);             
			v2Locate= LocateVex(G,v2);
			//生成新的边表节点pNode存放v1

			EdgeNode* pNode = new EdgeNode;
			pNode->adjvex = v2Locate;//邻接点序号为v2Locate
			pNode->nextArc = G.vertices[v1Locate].firstArc;//将pNode插入到v1的邻接表头部
			G.vertices[v1Locate].firstArc = pNode;

			//生成新的边表节点pNode存放v2
			EdgeNode* qNode = new EdgeNode;
			qNode->adjvex = v1Locate;
			qNode->nextArc =G.vertices[v2Locate].firstArc;
			G.vertices[v2Locate].firstArc = qNode;
		} 
 }

 void BFS(ALGraph G,int k)
 { 
	// 以vk为源点对用邻接表表示的图G进行广度优先搜索
	visited[k] = 1;
	cout << G.vertices[k].info << " ";
	q.push(k);//vk已访问，将其序号放入队列
	while(!q.empty())
	{
		int i = q.front();
		q.pop();//队头元素出队并置为vi,vi出队 
		EdgeNode *edge = G.vertices[i].firstArc;//取出vI的边表头指针
			while(edge)//依次搜索vi的邻接点vj 
				{
					if(!visited[edge->adjvex])
					{
						visited[edge->adjvex] = 1;
						cout << G.vertices[edge->adjvex].info << " ";
						q.push(edge->adjvex);//入队
					}
					edge = edge->nextArc;//找edge的下一邻接点 
				}
			} 
 }

void BFSTraverseN(ALGraph G)//广度优先遍历节点
{
	 for(int i = 0;i<G.VexNum;i++)//存放顶点的访问数组初始化
		 visited[i] = 0;
	  for(int i = 0;i<G.VexNum;i++)//依次访问节点
		 if(!visited[i])
			 BFS(G,i);
}


//深度优先遍历
void DFS(ALGraph G,int k)
{
	//以vi为出发点对邻接表表示的图G进行深度优先搜索
	visited[k] = 1;
	cout << G.vertices[k].info << " ";
	EdgeNode *edge = G.vertices[k].firstArc;//取出vI的边表头指针
	while(edge)
	{
		if(!visited[edge->adjvex])
			DFS(G,edge->adjvex);
		edge = edge->nextArc;
	}
}
void DFSTraverseN(ALGraph G)//广度优先遍历节点
{
	 for(int i = 0;i<G.VexNum;i++)//存放顶点的访问数组初始化
		 visited[i] = 0;
	  for(int i = 0;i<G.VexNum;i++)//依次访问节点
		 if(!visited[i])
			 DFS(G,i);
}


int _tmain(int argc, _TCHAR* argv[])
{

	ALGraph G;
	CreateUDG(G);
	
	cout<<"广度优先遍历"<<endl;     
	BFSTraverseN(G);
	cout << endl;

	cout<<"深度优先遍历"<<endl; 
	DFSTraverseN(G);
	system("pause");
	return 0;
}