图的遍历（BFS）

邻接矩阵储存的图

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;
const int MaxV = 100;

typedef struct QNode{
	int *Data;
	int Front, Rear;
	int MaxSize;
} * Queue;
typedef struct GNode{
	int Nv, Ne;
	int F[MaxV][MaxV];
	bool tag[MaxV];		//标记是否被访问
	//char Data[MaxV];	//顶点的数据
} * MGraph;
typedef struct ENode{
	int v1, v2;
	//int Weight;
} * Edge;
Queue CreateQueue(int MaxSize)
{
	Queue Q = (Queue)malloc(sizeof(QNode));
	Q->Data = (int *)malloc(sizeof(int) * MaxSize);
	Q->Front = Q->Rear = 0;		//队列空的条件, 始终使Q->Front指向位置不储存数据
	Q->MaxSize = MaxSize;		//于是, 队列满的判断条件为: (Rear + 1) % MaxSize == Front;
	return Q;					//队列中元素个数: (Rear - Front + MaxSize) % MaxSize
}
void AddQ(Queue Q, int x)	//入队
{
	Q->Rear = (1 + Q->Rear) % Q->MaxSize;
	Q->Data[Q->Rear] = x;
}
int DeleteQ(Queue Q)	//出队
{
	Q->Front = (Q->Front + 1) % Q->MaxSize;
	return Q->Data[Q->Front];
}

MGraph CreateGraph(int Nv)
{
	MGraph G = (MGraph)calloc(1, sizeof(GNode));
	G->Nv = Nv;
	return G;
}
void InsertEdge(MGraph G, Edge E)
{
	G->F[E->v1][E->v2] = 1;
	G->F[E->v2][E->v1] = 1;
}
MGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	MGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Edge E = (Edge)malloc(sizeof(ENode));
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->v1 >> E->v2;
		InsertEdge(G, E);
	}
	free(E);
	return G;
}

void Visit(MGraph G, int v)
{
	cout << "访问:" << v << endl;
}
void BFS(MGraph G, int v)
{
	Queue Q = CreateQueue(G->Nv);
	Visit(G, v);
	G->tag[v] = true;
	AddQ(Q, v);
	while (Q->Front != Q->Rear)	//如果队列非空
	{
		int w = DeleteQ(Q);
		for (int i = 0; i < G->Nv; i++)
			if(G->F[w][i] && !G->tag[i] )	//有边, 且没有被访问过
			{
				Visit(G, i);
				G->tag[i] = true;
				AddQ(Q, i);
			}
	}
	free(Q->Data);
	free(Q);
}

int main()
{
	MGraph G = BuildGraph();
	BFS(G, 0);
	free(G);
	system("pause");
	return 0;
}

输入数据

8 10
4 7
0 2
2 6
0 7
7 1
0 5
5 3
3 4
4 5
4 6

运行结果

邻接表储存的图

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;
const int MaxV = 100;
/*链式队列*/
struct Node{
	int Data;
	Node *Next;
};
typedef struct QNode{	//Front -> .... -> Rear
	Node *Front, *Rear;	//只在尾部插入, 这里采用不带空头结点
	//int MaxSize;
} * Queue;

typedef struct ENode{
	int v1, v2;
	//int Weight;
} * Edge;
struct AdjVNode{
	int AdjV;
	AdjVNode *Next;
};
typedef struct VNode{
	AdjVNode *EdgeFirst;
	bool tag;
	//int Data;
} AdjList[MaxV];
typedef struct GNode{
	int Nv, Ne;
	AdjList L;
} * LGraph;

Queue CreateQueue(int MaxSize)
{
	Queue Q = (Queue)calloc(1, sizeof(QNode));
	//Q->MaxSize = MaxSize;
	return Q;
}

void AddQ(Queue Q, int x)	//入队, 添加在尾部
{
	Node *A = (Node *)malloc(sizeof(Node));
	A->Data = x; A->Next = NULL;
	if (Q->Front == NULL)	//若为空队列入队, 因为要使Front与Rear在同一条链上, 所以分类讨论
	{
		Q->Rear = A;
		Q->Front = Q->Rear;	//此时Q->Front 非空, 表示队列非空, 队列只有一个元素
	}
	else
	{
		Q->Rear->Next = A;
		Q->Rear = A;
	}
}
int DeleteQ(Queue Q)		//出队
{
	Node *A = Q->Front;
	int x = A->Data;
	if (Q->Front == Q->Rear)	//若队列只有一个元素
		Q->Rear = Q->Front = NULL;
	else
		Q->Front = A->Next;
	free(A);
	return x;
}

LGraph CreateGraph(int Nv)
{
	LGraph G = (LGraph)calloc(1, sizeof(GNode));
	G->Nv = Nv;
	return G;
}
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *A;
	A = (AdjVNode *)malloc(sizeof(AdjVNode));
	A->AdjV = E->v2;
	A->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = A;
	/*如果是无向图, 再插入一条边*/
	A = (AdjVNode *)malloc(sizeof(AdjVNode));
	A->AdjV = E->v1;
	A->Next = G->L[E->v2].EdgeFirst;
	G->L[E->v2].EdgeFirst = A;
}
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Edge E = (Edge)malloc(sizeof(ENode));
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->v1 >> E->v2;
		InsertEdge(G, E);
	}
	free(E);
	return G;
}
void DeleteGraph(LGraph G)
{
	AdjVNode *A;
	for (int i = 0; i < G->Nv; i++)
		while (G->L[i].EdgeFirst)
		{
			A = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = A->Next;
			free(A);
		}
	free(G);
}
void Visit(LGraph G, int v)
{
	cout << "访问:" << v << endl;
}
void BFS(LGraph G, int v)
{
	Queue Q = CreateQueue(G->Nv);
	AdjVNode *A;
	Visit(G, v);
	G->L[v].tag = true;
	AddQ(Q, v);
	while (Q->Front)	//如果队列非空
	{
		int w = DeleteQ(Q);
		A = G->L[w].EdgeFirst;
		while (A)	//逐一访问v的其他相邻结点
		{
			if(G->L[A->AdjV].tag == false)	//如果是没有被访问的结点
			{
				Visit(G, A->AdjV);
				G->L[A->AdjV].tag = true;
				AddQ(Q, A->AdjV);
			}
			A = A->Next;
		}
	}
	free(Q);
}

int main()
{
	LGraph G = BuildGraph();
	BFS(G, 0);
	DeleteGraph(G);
	system("pause");
	return 0;
}

运行结果