【数据结构C语言】图的遍历——邻接矩阵

#include
#include
#define MaxInt 32767
#define MVNum 100
#define MAXSIZE 100




typedef struct
{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;




int LocateVex(AMGraph G,char v)
{
    int i;
    for(i=0;i         if(G.vexs[i]==v)
           return i;
}




//算法6.1采用邻接矩阵表示法创建无向网
int CreateUDN(AMGraph *G)
{//采用邻接矩阵表示法，创建无向网G
    char a;int i,j;
    printf("输入总顶点数,总边数，并用“,”隔开\n");
    scanf("%d,%d",&G->vexnum,&G->arcnum);
    scanf("%c",&a);//吃掉回车键




    printf("依次输入顶点的信息：");
    for(i=0;ivexnum;i++)
        scanf("%c",&G->vexs[i]);
    scanf("%c",&a);//吃掉回车键




    for(i=0;ivexnum;i++)
        for(j=0;jvexnum;j++)
           G->arcs[i][j]=MaxInt;




    printf("下面开始构造邻接矩阵：");
    char v1,v2;int w,k;
    for(k=0;karcnum;k++)
    {
         printf("输入一条边依附的顶点及权值：");
         scanf("%c%c%d",&v1,&v2,&w);
         scanf("%c",&a);
         i=LocateVex(*G,v1);j=LocateVex(*G,v2);
         G->arcs[i][j]=w;
         G->arcs[j][i]=G->arcs[i][j];
    }
return 0;
}


int PrintUDN(AMGraph G)
{
    printf("图的邻接矩阵结构是：");
    int i,j;
    printf("顶点元素是:");
    for(i=0;i         printf("vexs[%d]=%c ",i,G.vexs[i]);
    printf("\n构造的邻接矩阵是：\n");
    for(i=0;i         {
            for(j=0;j                 printf("%7d ",G.arcs[i][j]);
            printf("\n");
        }
}


//深度优先遍历
int visited[MaxInt];//数组visited[]为全局变量；数组若没初始化，则值为0
void DFS_AM(AMGraph G,int v)
{
    printf("%c ",G.vexs[v]);
    visited[v]=1;
    int w;
    for(w=0;w     {
        if((G.arcs[v][w]!=MaxInt)&&(!visited[w]))
            DFS_AM(G,w);
    }
}






//有关队列的函数
typedef struct
{
    int *base;
    int front;
    int rear;
}SqQueue;


int InitQueue(SqQueue *Q)
{
    (*Q).base=(int *)malloc(sizeof(int)*MAXSIZE);
    (*Q).front=(*Q).rear=0;
    return 0;
}


int EnQueue(SqQueue *Q,int e)
{
    if(((*Q).rear+1)%MAXSIZE==(*Q).front)
        printf("队列已满，入队失败！");
    (*Q).base[(*Q).rear]=e;
    (*Q).rear=((*Q).rear+1)%MAXSIZE;
    return 0;
}


int DeQueue(SqQueue *Q,int *e)
{
    if((*Q).front==(*Q).rear)
        printf("队空，出队失败！");
    *e=(*Q).base[(*Q).front];
    (*Q).front=((*Q).front+1)%MAXSIZE;
    return 0;
}


int QueueEmpty(SqQueue Q)


{
     if(Q.front==Q.rear)
        return 1;
     else return 0;
}




//广度优先遍历
int visited2[MaxInt]={0};
void BFS(AMGraph G,int v)
{
    printf("%c ",G.vexs[v]);
    visited2[v]=1;
    SqQueue Q;int u,w;
    InitQueue(&Q);
    EnQueue(&Q,v);
    while(!QueueEmpty(Q))
    {
        DeQueue(&Q,&u);
        for(w=0;w         {
            if((G.arcs[u][w]!=MaxInt)&&(!visited2[w]))
                {
                    printf("%c ",G.vexs[w]);
                    visited2[w]=1;
                    EnQueue(&Q,w);
                }
        }
    }
}




int main()
{
    AMGraph G;
    CreateUDN(&G);
    PrintUDN(G);
    printf("深度优先遍历的结果是：");
    DFS_AM(G,0);
    printf("\n广度优先遍历的结果是：");
    BFS(G,0);
    return 0;
}