广度优先遍历算法

广度优先遍历，这边就要涉及队列的处理，因为，我们一开始访问一个节点之后，访问跟这个结点直接相连的所有节点，这样相连的节点依次加入队列当中，保持队列的先进先出，每次出一个，再访问出的这个节点直接相连的节点，仍然依次进入队列当中。

这边我们知道队列的最大元素的个数，这边采用循环队列的结构。

typedef struct
{
    int data[MAXSIZE];
    int front;
    int rear;
}Queue;

给出队列的入队，出队操作。

int enQueue(Queue *q,int e)
{
    if((q->rear+1)%MAXSIZE==q->front)
    {
        return 0;
    }
    q->data[q->rear]=e;
    q->rear=(q->rear+1)%MAXSIZE;
    return 1;
}

int deQueue(Queue *q,int *e)
{
    if(q->front==q->rear)
        return 0;
    *e=q->data[q->front];
    q->front=(q->front+1)%MAXSIZE;
    return 1;
}

给出整个代码：

#include <stdio.h>

#define MAXVEX 9
#define INFINITY 65535
#define MAXSIZE 9 //队列最大储存

typedef struct MGraph
{
    char vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;

typedef struct
{
    int data[MAXSIZE];
    int front;
    int rear;
}Queue;

int visited[MAXVEX];

int initQueue(Queue *q);
int queueEmpty(Queue q);
int enQueue(Queue *q,int e);
int deQueue(Queue *q,int *e);
void createMGraph(MGraph *g);
void BFSTraverse(MGraph g);


int initQueue(Queue *q)
{
    q->front=0;
    q->rear=0;
    return 1;
}

int queueEmpty(Queue q)
{
    if(q.front==q.rear)
        return 1;
    else
        return 0;
}

int enQueue(Queue *q,int e)
{
    if((q->rear+1)%MAXSIZE==q->front)
    {
        return 0;
    }
    q->data[q->rear]=e;
    q->rear=(q->rear+1)%MAXSIZE;
    return 1;
}

int deQueue(Queue *q,int *e)
{
    if(q->front==q->rear)
        return 0;
    *e=q->data[q->front];
    q->front=(q->front+1)%MAXSIZE;
    return 1;
}

void createMGraph(MGraph *g)
{
    int i, j;

    g->numEdges=15;
    g->numVertexes=9;

    g->vexs[0]='A';
    g->vexs[1]='B';
    g->vexs[2]='C';
    g->vexs[3]='D';
    g->vexs[4]='E';
    g->vexs[5]='F';
    g->vexs[6]='G';
    g->vexs[7]='H';
    g->vexs[8]='I';


    for (i = 0; i < g->numVertexes; i++)
    {
        for ( j = 0; j < g->numVertexes; j++)
        {
            g->arc[i][j]=0;
        }
    }

    g->arc[0][1]=1;
    g->arc[0][5]=1;

    g->arc[1][2]=1;
    g->arc[1][8]=1;
    g->arc[1][6]=1;

    g->arc[2][3]=1;
    g->arc[2][8]=1;

    g->arc[3][4]=1;
    g->arc[3][7]=1;
    g->arc[3][6]=1;
    g->arc[3][8]=1;

    g->arc[4][5]=1;
    g->arc[4][7]=1;

    g->arc[5][6]=1;

    g->arc[6][7]=1;


    for(i = 0; i < g->numVertexes; i++)
    {
        for(j = i; j < g->numVertexes; j++)
        {
            g->arc[j][i] =g->arc[i][j];
        }
    }

}

void BFSTraverse(MGraph g)
{
    int i,j;
    Queue q;
    for(i=0;i<g.numVertexes;i++)
        visited[i] = 0;
    initQueue(&q);
    for(i=0;i<g.numVertexes;i++)
    {
        if(visited[i]!=1)
        {
            visited[i]=1;
            printf("%c ",g.vexs[i]);
            enQueue(&q,i);
            while(!queueEmpty(q))
            {
                deQueue(&q,&i);
                for(j=0;j<g.numVertexes;j++)
                {
                    if(g.arc[i][j]==1&& visited[j]!=1)
                    {
                        visited[j]=1;
                        printf("%c ",g.vexs[j]);
                        enQueue(&q,j);
                    }
                }
            }
        }
    }
}

int main()
{
    MGraph g;
    createMGraph(&g);
    BFSTraverse(g);
    return 0;
}