图的遍历算法之广度优先遍历（BFS）(C++)

图的广度优先遍历算法和树的层序遍历相类似。

其思想是：从第一个结点开始遍历，访问第一个结点后，依次访问该结点的相邻结点，再把从这些访问过得结点中依次访问它们的相邻结点，直至访问完所有的结点。

 广度优先遍历需要借助队列保存当前已经访问过得结点，以便于取出结点访问其相邻结点。

注意：由于图的存储方式有2中：邻接矩阵和邻接表。二者的存储特性决定了使用广度优先遍历的时间复杂度也是不同的。

广度优先遍历图的邻接矩阵存储的时间复杂度是O（v^2）;

广度优先遍历图的邻接表存储的时间复杂度是O（V+E）;

算法核心：

void BFS(GraAdList G,int v) {
	int front, rear,j;
	int queue[MAX];
	front = rear = -1;
	EdgeNode* p;
	cout << G.AdList[v].data << " ";
	visited[v] = 1;
	queue[++rear] = v;
	while (front != rear) {
		v = queue[++front];
		p = G.AdList[v].first;
		while (p)
		{
			j = p->adjvex;
			if (visited[j] == 0)
			{
				cout << G.AdList[j].data << " ";
				visited[j] = 1;
				queue[++rear] = j;
			}
			p = p->next;
		}
	}
}

其中传参V代表从哪个结点开始访问，并设置辅助数组visited[max],大小为图的结点数，初始化为0,访问过得结点将其值设为1，代表访问过。

整体算法思想实现过程如上述：

从图中选中一个结点V，从结点v开始进行广度优先遍历；

访问v，并visited[v]的值改为1，将v入队；

进入循环，如果队列不为空，取出队列首元素，辅助指针指向首元素的first。如果没有访问过，访问该元素，并将该元素入队。

直至队列为空为止，遍历也结束。

完整代码：

#include<iostream>
using namespace std;
#define MAX 6
int visited[MAX];
typedef struct EdgeNode {
	int adjvex;
	EdgeNode* next;
};
typedef struct VexNode {
	char data;
	EdgeNode* first;
};
typedef struct GraAdList {
	VexNode AdList[MAX];
	int vexnum;
	int edgenum;
};
//创建邻接矩
void Creat(GraAdList& G) {
	int i, j, k;
	EdgeNode* e = NULL;
	EdgeNode* q = NULL;
	cout << "请输入顶点数和边数： " << endl;
	cin >> G.vexnum >> G.edgenum;
	cout << "请输入顶点信息" << endl;
	for (k = 0; k < G.vexnum; k++)
	{
		cin >> G.AdList[k].data;
		G.AdList[k].first = NULL;
	}
	for (k = 0; k < G.edgenum; k++)
	{
		cout << "请输入边(vi,vj)的下标i,j： " << endl;
		cin >> i >> j;
		e = new EdgeNode;
		e->adjvex = j;
		e->next = G.AdList[i].first;
		G.AdList[i].first = e;
		/*q = new EdgeNode;
		q->adjvex = i;
		q->next = G.AdList[j].first;
		G.AdList[j].first = q;*/
	}
}
void myprint(GraAdList G){
	cout << endl << "邻接表: " << endl;
	EdgeNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		cout << G.AdList[i].data << ": ";
		for (p = G.AdList[i].first; p; p = p->next)
		{
			cout << p->adjvex << " ";
		}
		cout << endl;
	}
}
void BFS(GraAdList G,int v) {
	int front, rear,j;
	int queue[MAX];
	front = rear = -1;
	EdgeNode* p;
	cout << G.AdList[v].data << " ";
	visited[v] = 1;
	queue[++rear] = v;
	while (front != rear) {
		v = queue[++front];
		p = G.AdList[v].first;
		while (p)
		{
			j = p->adjvex;
			if (visited[j] == 0)
			{
				cout << G.AdList[j].data << " ";
				visited[j] = 1;
				queue[++rear] = j;
			}
			p = p->next;
		}
	}
}
int main() {
	GraAdList G;
	Creat(G);
	myprint(G);
	for (int i = 0; i < G.vexnum; i++)
	{
		visited[i] = 0;
	}
	cout << endl << "广度有限遍历： " << endl;
	BFS(G, 0);
	return 0;
}

执行结果：

我创建的图：