广度优先遍历是连通图的一种遍历策略。其基本思想如下：

1、从图中某个顶点V0出发，并访问此顶点；

2、从V0出发，访问V0的各个未曾访问的邻接点W1，W2，…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点；

3、重复步骤2，直到全部顶点都被访问为止。

例如下图中：

1.从A开始，首先找到A的关联顶点D,E

2.由D出发，找到B，C；由E出发，找到A，但是A已经遍历过，所以忽略。

3.由B出发，没有关联顶点；由C出发，没有关联顶点。

所以最后顺序是A,D,E,B,C
0 0 0 1 1
0 0 0 1 1
0 0 0 1 0
1 1 1 0 0
1 1 0 0 0
c语言实现如下：（使用邻接矩阵存储）

include”stdio.h”

include”stdlib.h”

define MAX_SIZE 10

typedef char Elemtype;
typedef int status;
//创建队列 
typedef struct QNode{
Elemtype data;
QNode *next;        
}QNode,*Queueptr;
typedef struct{
Queueptr front,rear;
}LinkQueue; 
//图的结构体 
typedef struct{
int vexnum;//结点数量 
Elemtype vex[MAX_SIZE];//结点数据 
int cmb[MAX_SIZE][MAX_SIZE];//各节点间的联系 
}Graph;
status initQueue(LinkQueue &Q)
{
Q.front = Q.rear = (Queueptr)malloc(sizeof(QNode));
if(!Q.front)
{
    exit(0);
}
Q.front->next = NULL;  
return 0;
}
status enQueue(LinkQueue &Q,Elemtype c)
{
Queueptr p = (Queueptr)malloc(sizeof(QNode));
if(!p) exit(0);
p->data = c;
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
return 0;
}
status deQueue(LinkQueue &Q,Elemtype &c)
{
Queueptr p = Q.front->next;
c = p->data;
Q.front->next = p->next;
if(Q.rear == p) Q.rear = Q.front;
free(p);
return 0; 
}
status emptyQueue(LinkQueue Q)
{
if(Q.front != Q.rear)
{
    return 0;
}
else return 1;

}
int main()
{
LinkQueue Q;
initQueue(Q);
Elemtype c,e;
Graph G;
int n,visit[MAX_SIZE],i,j;
printf("请输入图结点数量:\n");
scanf("%d",&n);
scanf("%c",&e);//接收回车 
for(int i = 0;i<n;i++)
    visit[i] = false;
G.vexnum = n;
printf("输入数据：\n");
for(i=0;i<G.vexnum;i++)
{
    scanf("%c",&G.vex[i]);

}
scanf("%c",&e);//接收回车 
printf("请输入图顶点之间的关系(下三角)：\n");
for( i = 0;i<G.vexnum;i++)
{
    for( j = 0;j<=i;j++)
    {
        scanf("%d",&G.cmb[i][j]);
        G.cmb[j][i] = G.cmb[i][j];
    }
}
//核心代码块
for(i=0;i<G.vexnum;i++)
{
    if(!visit[i]) 
    {
    visit[i] = true;
    enQueue(Q,G.vex[i]);
    while(!emptyQueue(Q))
    {
        deQueue(Q,c);//出栈 
        printf("%2c",c);
        for(j=0;j<G.vexnum;j++)//出栈元素的下一层元素入栈 
        {
            if(G.cmb[i][j]&&!visit[j])
            {
                visit[j] = true;
                enQueue(Q,G.vex[j]);

            }
        }
    }
}
//核心代码块
}
}

运行结果