图的广度优先搜索

#include <stdio.h>
#include <stdlib.h>
#define MAX 20
typedef enum {FALSE,TRUE} Boolean;
typedef int Status;
Boolean visited[MAX];
//邻接表结构表示的图
#include <limits.h>
#define MAX_VERTEX_NUM 20
#define OK 1
#define ERROR 0
typedef int InfoType;  //定义弧相关信息为整形
typedef char VertexType;    //定义顶点类型为字符型
typedef enum {DG,DN,UDG,UDN} GraphKind;    //定义{有向图，有向网，无向图，无向网}等枚举常量，同时定义GraphKind为枚举变量类型

typedef struct ArcNode
{
    int adjvex;               //该弧所指向的顶点在顺序结构中的位置
    struct ArcNode *nextarc;  //与该弧邻接(同一尾结点)的下一条弧的指针
    InfoType *info;           //该弧相关信息的指针
}ArcNode;                     //弧结构

typedef struct VNode
{
    VertexType data;            //顶点
    ArcNode *firstarc;          //指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM]; //顶点结构

typedef struct
{
    AdjList vertices;     //顶点数组
    int vexnum,arcnum;    //顶点数和弧数
    GraphKind kind;
}ALGraph;                 //邻接表表示的图结构

//队列结构
typedef struct
{
    VNode *Q[MAX];
    int first,last;
}Queue;
//队列方法
void EnQueue(Queue Q,VNode *v);
void DeQueue(Queue Q,VNode *v);
Boolean QueueEmpty(Queue Q);

void BFSTraverse(ALGraph G);

int FirstAdjVex(ALGraph G,int v);
int NextAdjVex(ALGraph G,int v,int w);
int LocateVex(ALGraph G,VertexType v);
Status CreateUDG(ALGraph *G);

int main()
{
    ALGraph *G;
    G=(ALGraph *)malloc(sizeof(ALGraph));

    CreateUDG(G);
    int i;
    printf("图结构：\n");
    for(i=0;i<G->vexnum;i++)
    {
        ArcNode *p;
        p=(ArcNode *)malloc(sizeof(ArcNode));
        p=G->vertices[i].firstarc;
        printf("%c ",G->vertices[i].data);
        while(p)
        {
            VertexType t;
            int k;
            k=p->adjvex;
            t=G->vertices[k].data;
            printf("%c ",t);

            p=p->nextarc;
        }
        printf("\n");
    }
    printf("深度优先搜索：");
    BFSTraverse(*G);
    return 0;
}
int LocateVex(ALGraph G,VertexType v)
{
    int i;
    for(i=0;i<G.vexnum;i++)
        if(G.vertices[i].data==v)
            return i;
}

//创建无向图
Status CreateUDG(ALGraph *G)
{
   int i,IncInfo;
    printf("输入顶点数量：");
    scanf("%d",&G->vexnum);
    printf("输入弧数量：");
    scanf("%d",&G->arcnum);
    printf("弧是否含有其他信息（否---0,是---1）：");
    scanf("%d",&IncInfo);
    //头结点处理
    for(i=0;i<G->vexnum;i++)
    {
        fflush(stdin);
        printf("输入第%d个顶点：",i+1);
        scanf("%c",&G->vertices[i].data);    //输入头结点的顶点信息
        G->vertices[i].firstarc=NULL;        //初始化头结点的弧指针
    }
    //弧结点处理
    for(i=0;i<G->arcnum;i++)
    {
        char v1,v2;
        int node1,node2;
        fflush(stdin);
        printf("输入第%d条弧的依附的第一个结点：",i+1);
        scanf("%c",&v1);
        fflush(stdin);
        printf("输入第%d条弧的依附的第二个结点：",i+1);
        scanf("%c",&v2);

        node1=LocateVex(*G,v1);
        node2=LocateVex(*G,v2);

        ArcNode *p1,*p2;
        //两个指针变量虽然是同一类型，但不能用一条分配内存语句同时分配，否则为同一指针变量，即指向同一地址
        p1=(ArcNode *)malloc(sizeof(ArcNode));
        p2=(ArcNode *)malloc(sizeof(ArcNode));

        p1->adjvex=node1;
        p2->adjvex=node2;
        p1->nextarc=G->vertices[node2].firstarc;
        G->vertices[node2].firstarc=p1;
        p2->nextarc=G->vertices[node1].firstarc;
        G->vertices[node1].firstarc=p2;
        if(IncInfo)
        {
            int info;
            printf("输入弧的其他信息：");
            scanf("%d",&info);
            p1->info=p2->info=&info;
        }
        else
            p1->info=p2->info=NULL;
    }
    return OK;
}
//广度优先搜索
void BFSTraverse(ALGraph G)
{
    Queue Q;
    Q.first=Q.last=0;

    int i;
    for(i=0;i<G.vexnum;i++)
        visited[i]=FALSE;
    for(i=0;i<G.vexnum;i++)
    {
        if(!visited[i])
        {
            visited[i]=TRUE;
            printf("%c ",G.vertices[i].data);

            EnQueue(Q,&G.vertices[i]);
            while(!QueueEmpty(Q))
            {
                VNode *t;
                t=(VNode *)malloc(sizeof(VNode));

                DeQueue(Q,t);
                int w,u;
                u=LocateVex(G,t->data);
                for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
                    if(!visited[w])
                    {
                        visited[w]=TRUE;
                        printf("%c ",G.vertices[w].data);
                        EnQueue(Q,&G.vertices[w]);
                    }
            }
        }
    }
}
//求位置v结点的第一个邻接点
int FirstAdjVex(ALGraph G,int v)
{
    if(G.vertices[v].firstarc)
        return G.vertices[v].firstarc->adjvex;
    else
        return -1;
}
//求位置v结点就w外的其他邻接点
int NextAdjVex(ALGraph G,int v,int w)
{
    ArcNode *p;
    p=(ArcNode *)malloc(sizeof(ArcNode));

    p=G.vertices[v].firstarc;
    while(p)
    {
        if(p->adjvex==w || visited[p->adjvex])
            p=p->nextarc;
        else
            return p->adjvex;
    }
    return -1;
}
//队列操作方法
void EnQueue(Queue Q,VNode *v)
{
    Q.Q[Q.last++]=v;
}
void DeQueue(Queue Q,VNode *v)
{
    v=Q.Q[Q.first++];
}
Boolean QueueEmpty(Queue Q)
{
    return Q.first==Q.last;
}