图的广度优先算法全部代码，使用邻接矩阵，包括FirstNeighbor函数以及NextNeighbor函数的实现

话不多说，直接上代码，注意代码中顶点的序号是从1开始，但是存放顶点的数组序号是从0开始，所以在代码中需要实现一个函数该函数来通过顶点找到对应的下标，辅助队列使用的是带头结点的链式队列

辅助对列相关代码：

//队列结构体
struct LinkNode { //链式队列结点
	int data;     //队列中图的顶点
	LinkNode* next;
};

struct LinkQueue { //链式队列
	LinkNode* front, * rear; //队列的队头和队尾指针
};

//初始化 带头结点
void InitQueue(LinkQueue& q)
{
	q.front = q.rear = new LinkNode; //申请一段空间做头结点  让front 和 rear 同时都指向头结点
	q.front->next = NULL;
}

//判断是否为空
bool IsEmpty(LinkQueue q)
{
	if (q.front == q.rear)  //也可用 q.front -> next == NULL
	{
		return true;
	}
	else
	{
		return false;
	}
}

//入队
void EnQueue(LinkQueue& q, int element)
{
	LinkNode* s = new LinkNode; //申请一个新结点
	s->data = element; 
	s->next = NULL; //s作为最后一个结点，指针域指向NULL
	q.rear->next = s; //新结点插入到当前的rear之后
	q.rear = s; //表尾指针指向新的表尾
} 

//出队
bool DeQueue(LinkQueue& q, int& element)
{
	if (IsEmpty(q)) //判断队列是否为空，空的话直接返回
	{
		return false;
	}
	LinkNode* s = q.front->next; //队列中队头元素的指针
	element = s->data; //队头元素
	q.front->next = s->next; //修改头结点的next指针
	if (q.rear == s) //队列中只有一个元素
	{
		q.rear = q.front; //修改队尾指针
	}
	delete(s); //释放结点空间
	return true;
}

开始：

//访问顶点
void visit(int )
{
	cout << v;
}

//找到顶点v的对应下标
int LocateVex(Graph g, int v)
{
	for (int i = 0; i < g->vexnum; i++)
		if (g->Vex[i] == v)  //g->Vex[i]代表数组序号i所对应的顶点号
			return i;
}

//求图 G 中顶点 x 的第一个邻接点，若有则返回顶点号。若x没有邻接
//点或图中不存在 x，则返回 - 1
int FirstNeighbor(Graph g, int x)
{
	int x1 = LocateVex(g, x);
	for (int i = 0; i < g->vexnum; i++)
	{
		if (g->Edge[x1][i] == 1)
		{
			return g->Vex[i];
		}
	}
	return -1;
}

//假设图 G 中顶点 y 是顶点 x 的一个邻接点，返回除 y 之外顶点 x 的
//下一个邻接点的顶点号，若 y 是 x 的最后一个邻接点，则返回 - 1
int NextNeighbor(Graph g, int x, int y)
{
	int x1 = LocateVex(g, x);
	int y1 = LocateVex(g, y);
	for (int i = y1; i < g->vexnum; i++)
	{
		if (g->Edge[x1][i] == 1 && i != y1)
		{
			return g->Vex[i];
		}
	}
	return -1;
}

//从顶点v开始，广度优先遍历图G
void BFS(Graph g, int v)
{
	int w;
	visit(v);
	visited[LocateVex(g, v)] = true;
	LinkQueue q;
	InitQueue(q); // 初始化
	EnQueue(q, v); //顶点v入队
	while (!IsEmpty(q)) //队列不为空
	{
		DeQueue(q, v); //顶点v出队
		for (w = FirstNeighbor(g, v); w >= 0; w = NextNeighbor(g, v, w))
		{
			//检测v的所有邻接点
			if (!visited[LocateVex(g, w)])  //w为v的尚未访问的邻接顶点,并且该结点存在
			{
				visit(w); //访问顶点w
				visited[LocateVex(g, w)] = true; //对w做已访问标记
				EnQueue(q, w); //顶点w入队列
			}
		}
	}
}

// 对图G进行广度优先遍历
void BFSTraverse(Graph g) {
	for (int i = 0; i < g->vexnum; ++i) //访问标记数组初始化
		visited[i] = false; //visited数组用于判断顶点是否被访问过
	for (int i = 0; i < g->vexnum; ++i) //从0号结点开始遍历，对每个连通分量进行一次广度优先遍历
		if (!visited[i])
			BFS(g, g->Vex[i]);  //g->Vex[i]代表下标所对用的顶点号
}

在测试的时候，插入数据我采用的是依次输入顶点数，边数，以及对邻接矩阵进行赋值，代码如下：

//插入数据
void test(Graph g)
{
	g->vexnum = 8;
	g->archum = 10;
	for (int i = 0; i < g->vexnum; i++)
	{
		g->Vex[i] = i + 1;
	}
	for (int i = 0; i < g->vexnum; i++)
	{
		for (int j = 0; j < g->vexnum; j++)
		{
			g->Edge[i][j] = 0;
		}
	}
	int v1, v2, i, j;
	//输入有边的两个顶点，将其边表所在位置 置为1
	for (int k = 0; k < g->archum; k++)
	{
		cout << "输入第" << k + 1 << "边的第一个顶点: ";
		cin >> v1;
		cout << "输入第" << k + 1 << "边的第二个顶点: ";
		cin >> v2;
		i = LocateVex(g, v1);				//找到顶点i的下标
		j = LocateVex(g, v2);				//找到顶点j的下标
		g->Edge[i][j] = g->Edge[j][i] = 1; //1表示顶点i和j之间有边，无向图不区分方向
	}
}

注意，边数以及顶点数也可以自己输入，我这里是直接进行赋值了，最后进行验证

int main()
{
	Graph g = new(MGraph);
	//MGraph g;
	//插入数据
	test(g);
	//进行广度优先遍历
	BFSTraverse(g);
	return 0;
}

下图来自王道考研视频，验证中也是从顶点1开始遍历，当然可以自己指定顶点进行验证

结果如下：

如有错误请指正！