建立一有向图的邻接矩阵存储结构，并对其进行广度优先搜索，输出得到的序列。

.cpp结尾

算法思想：
1、创建邻接矩阵以存储图的关系：有向图的关系可以用邻接矩阵中的1或0代表，1表示顶点之间有关系，且行->列；0则无关。若两顶点v1,v2之间有指向关系，则使v1所在的行与v2所在的列的元素变为1。重复操作，即使关系存储完成。
2、广度优先搜索： 在广度优先搜索算法中，解答树上结点的扩展是按它们在树中的层次进行的。首先生成第一层结点，同时检查目标结点是否在所生成的结点中，如果不在，则将所有的第一层结点逐一扩展，得到第二层结点，并检查第二层结点是否包含目标结点，……，对层次为n+1的任一结点进行扩展之前，必须先考虑层次完层次为n的结点的每种可能的状态。因此，对于同一层结点来说，求解问题的价值是相同的，可以按任意顺序来扩展它们。通常采用的原则是先生成的结点先扩展。

流程图：(仅供参考)

代码如下：

#include<stdio.h>
#include<stdlib.h>

#define TRUE 1                /*状态码预定义*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define INFINITY 99999999
#define MAX_VERTAX_NUM 20 //最大顶点个数
#define MAXQSIZE 50

typedef int Status;
typedef char VertexType;
typedef int VRType;
typedef int InfoType;

typedef int AdjMatrix;
typedef int QElemtype;

typedef struct
{
    QElemtype *base;
    int front,rear;
}SqQueue;

Status InitQueue(SqQueue *Q)   /*初始化队列*/
{
    Q->base=(QElemtype*)malloc(sizeof(QElemtype));
    if(!Q->base) exit(OVERFLOW);
    Q->front=Q->rear=0;
    return OK;
}

Status EnQueue(SqQueue *Q,QElemtype e)   /*入队操作*/
{
    if((Q->rear+1)%MAXQSIZE==Q->front)     /*If the queue is full*/
    {
        printf("The queue is full!\n");    
        return ERROR;   
    }
    Q->base[Q->rear]=e;      
    Q->rear=(Q->rear+1)%MAXQSIZE;
    return OK;
}

Status Dequeue(SqQueue *Q,QElemtype *e)   /*出队操作*/
{
    if(Q->front==Q->rear) 
    {
        printf("The queue is empty!\n");
        return ERROR;
    }
    *e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXQSIZE;
    return OK;
}

Status QueueEmpty(SqQueue q)   /*判断队列是否空*/
{
    return q.rear==q.front;
}


typedef struct 
{
    VertexType vexs[MAX_VERTAX_NUM];
    AdjMatrix arcs[MAX_VERTAX_NUM][MAX_VERTAX_NUM];
    int vexnum,arcnum;
    //GraphKind kind;
}MGraph;

int LocateVex(MGraph G, VertexType e)
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(G.vexs[i]==e)
            return i;
    }
    return -1;
}

Status CreateDG(MGraph &G)
{
    int i,j,k;
    char v1,v2;
    printf("请输入图的顶点个数（vexnum），边数（arcnum）：(例：4 4)");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("请输入顶点（例：abcd）:");
    for(i=0;i<G.vexnum;i++)
        G.vexs[i]=getchar();
    getchar();
    for(i=0;i<G.vexnum;i++)
        for(j=0;j<G.vexnum;j++)
            G.arcs[i][j]=INFINITY;
    for(k=0;k<G.arcnum;k++)
    {
        printf("请输入两个顶点（例：ab代表a->b）:");
        scanf("%c%c",&v1,&v2);
        getchar();
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        G.arcs[i][j]=1;
    }
    return OK;
}

int FirstAdjVex(MGraph G,int v)
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(G.arcs[v][i]==1)
            return i;
    }
    return -1;
}

int NextAdjVex(MGraph G,int u,int w)
{
    for(int i=w+1;i<G.vexnum;i++)
    {
        if(G.arcs[u][i]==1)
            return i;
    }
    return -1;
}

void BFSTraverse(MGraph G)
{
    SqQueue Q;
    int v,u,w,visited[MAX_VERTAX_NUM];
    for(v=0;v<G.vexnum;++v)  visited[v]=FALSE;
    InitQueue(&Q);
    for(v=0;v<G.vexnum;v++)
    {
        if(!visited[v])
        {
            visited[v]=TRUE;
            printf("%c",G.vexs[v]);
            EnQueue(&Q,v);
            while(!QueueEmpty(Q))
            {
                Dequeue(&Q,&u);
                for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
                {
                    if(!visited[w])
                    {
                        visited[w]=TRUE; printf("%c",G.vexs[w]);
                        EnQueue(&Q,w);
                    }
                }
            }
        }
    }
    printf("\n广度优先搜索完成\n");
}

int main()
{
    MGraph G;
    CreateDG(G);
    BFSTraverse(G);   //广度优先搜索
    system("pause");
    return 0;
}