一步两步学算法之图的广度搜索

bfs利用队列搜索    详细看代码

#define VERTEX_MAX 26                //图的最大定点数
#define MAXVALUE 32767                 //最大值
#include "stdio.h"
#define QUEUE_MAXSIZE 10             //队列最大容量
typedef struct
{
    char Vertex[VERTEX_MAX];            //保存定点信息的数组
    int Edges[VERTEX_MAX][VERTEX_MAX];    //边的权
    int IsTrav[VERTEX_MAX];                 //遍历标记
    int VertexNum;                        //定点数量
    int EdgeNum;                        //边的数量
    int GraphType;                        //图的类型
}MatrixGraph;                            //邻接矩阵结构
typedef struct
{
    int Data[QUEUE_MAXSIZE];
    int head;
    int tail;
}SeqQueue;                //队列结构
void BFSM(MatrixGraph *G,int k);
void CreateMatrixGraph(MatrixGraph *G);
void OutMatrix(MatrixGraph *G); 

void CreateMatrixGraph(MatrixGraph *G)
{
    int i,j,k,weight;
    char start,end;
    printf("输入各顶点信息\n");
    for(i=0;i<G->VertexNum;i++)
    {
        getchar();
        printf("第%d个顶点：",i+1);
        scanf("%c",&(G->Vertex[i]));            //输入顶点信息
    }
    printf("输入构成各边的两个顶点及权值（用逗号分隔）:\n");
    for(k=0;k<G->EdgeNum;k++)
    {
        getchar();
        printf("第%d条边：",k+1);
        scanf("%c,%c,%d",&start,&end,&weight);            //输入边的两头节点 和权值
        for(i=0;i<G->VertexNum;i++)                //从已有的顶点信息数组找这两个顶点并赋予权值
        {
            if(start==G->Vertex[i]){
                for(j=0;j<G->VertexNum;j++)
                {
                    if(end==G->Vertex[j])
                    {
                        G->Edges[i][j]=weight;
                            if(G->GraphType==0)
                                G->Edges[j][i]=weight;
                    }
                }
            }

        }
    }
} 

void OutMatrix(MatrixGraph *G)
{
    int i,j;
    for(j=0;j<G->VertexNum;j++)
        printf("\t%c",G->Vertex[j]);
    printf("\n");
    for(i=0;i<G->VertexNum;i++)
    {
        printf("%c",G->Vertex[i]);
        for(j=0;j<G->VertexNum;j++)
        {
            if(G->Edges[i][j]==MAXVALUE)
                printf("\t*");
            else
                printf("\t%d",G->Edges[i][j]);
        }
        printf("\n");
    }
}
void QueueInit(SeqQueue *Q)
{
    Q->head=Q->tail=0;
}
int QueueIsEmpty(SeqQueue *Q)
{
    return Q->head==Q->tail;
}
int QueueIn(SeqQueue *Q,int ch)
{
    if((Q->tail+1)%QUEUE_MAXSIZE==Q->head)
        return 0;
    Q->Data[Q->tail]=ch;
    Q->tail=(Q->tail+1)%QUEUE_MAXSIZE;
    return 1;
}
int QueueOut(SeqQueue *Q,int *ch)
{
    if(Q->head==Q->tail)
        return 0;
    *ch=Q->Data[Q->head];
    Q->head=((Q->head+1)%QUEUE_MAXSIZE);
    return 1;
}

void BFSraverse(MatrixGraph *G)
{
    int i;
    for(i=0;i<G->VertexNum;i++)
        G->IsTrav[i]=0;
    printf("广度优先遍历节点");
    for(i=0;i<G->VertexNum;i++)
        if(!G->IsTrav[i])
            BFSM(G,i);
    printf("\n");
}

void BFSM(MatrixGraph *G,int k)
{
    int i,j;
    SeqQueue Q;
    QueueInit(&Q);
    G->IsTrav[k]=1;
    printf("->%c",G->Vertex[k]);

    QueueIn(&Q,k);
    while(!QueueIsEmpty(&Q))
    {
        QueueOut(&Q,&i);
        for(j=0;j<G->VertexNum;j++)
        {
            if(G->Edges[i][j]!=MAXVALUE&&!G->IsTrav)
            {
                printf("->%c",G->Vertex[j]);
                G->IsTrav[j]=1;
                QueueIn(&Q,j);
            }
        }
    }
}