基于邻接矩阵的图的建立与遍历

以上图为例，通过邻接矩阵的方式存储该图，并写出建立图和遍历图的代码``

代码的实现比较简单和基础，主要用于巩固和复习数据结构相关知识。

#include <stdio.h>
#include <string.h>

#define MAX_VERTEX_NUM 100
#define MAX_VERTEX_NAMELEN 100

typedef struct{
    char name[MAX_VERTEX_NAMELEN];
}VerType;

// 图的邻接矩阵存储结构
typedef struct{
    int VertexNum,EdgeNum;                        // 顶点数，边数
    VerType Vertex[MAX_VERTEX_NUM];               // 顶点集
    int Edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];     // 边集
}MGragh;

// 记录顶点的访问信息
int visit[MAX_VERTEX_NUM];

//********************************************************//
//                    邻接矩阵建图                          //
//********************************************************//

void CreateMGragh(MGragh *Gra)
{
    int i,j,k;
    char v1[MAX_VERTEX_NAMELEN],v2[MAX_VERTEX_NAMELEN];

    printf("请输入顶点数及边数(顶点数 边数)
");
    scanf("%d %d%*c",&(Gra->VertexNum),&(Gra->EdgeNum));

    printf("请输入顶点信息
");
    for (i=0; i<Gra->VertexNum; i++){
        printf("%d.",i+1);
        gets(Gra->Vertex[i].name);
    }

    // 初始化邻接矩阵
    for (i=0; i<Gra->VertexNum; i++){
        for (j=0; j<Gra->VertexNum; j++){
            Gra->Edge[i][j] = 0;
        }
    }
    printf("请输入边信息(顶点，顶点)
");
    for (i=0; i<Gra->EdgeNum; i++){
        printf("%d.",i+1);
        scanf("%[^,]%*c%[^
]%*c",v1,v2);
        for (j=0; j<Gra->VertexNum; j++){
            for (k=0; k<Gra->VertexNum; k++){
                if (strcmp(Gra->Vertex[j].name,v1) == 0 && strcmp(Gra->Vertex[k].name,v2) == 0){
                    Gra->Edge[j][k] = Gra->Edge[k][j] = 1;
                }
            }
        }
    }
}

//********************************************************//
//                   深度优先遍历                           //
//********************************************************//

void DFS(MGragh *Gra,int sub)
{
    printf("%s",Gra->Vertex[sub].name);
    visit[sub] = 1;
    for (int i=0; i<Gra->VertexNum; i++){
        if (Gra->Edge[sub][i] == 1 && visit[i] == 0){
            DFS(Gra,i);
        }
    }
}

void DFSTraverse(MGragh *Gra)
{
    int i;

    // 初始化
    for (i=0; i<Gra->VertexNum; i++){
        visit[i] = 0;
    }

    for (i=0; i<Gra->VertexNum; i++){
        if (visit[i] == 0){
            DFS(Gra,i);
            printf("
");
        }
    }
}

//********************************************************//
//                   广度优先遍历                           //
//********************************************************//

typedef struct{
    int first;
    int last;
    int que[MAX_VERTEX_NUM];                
}Queue;

void initQueue(Queue *q)                            // 初始化队列
{
    q->first = q->last = 0;
}
int QueueEmpty(Queue *q)                            // 判断队列为空
{
    return q->last==q->first;
}
int QueueFull(Queue *q)                             // 判断队列为满
{
    return (q->last-q->first) == MAX_VERTEX_NUM;
}
void DeQueue(Queue *q,int *i)                       // 出队
{
    *i = q->que[q->first];
    q->first = (q->first+1)%MAX_VERTEX_NUM;
}
void EnQueue(Queue *q,int i)                        // 入队
{
    q->que[q->last] = i;
    q->last = (q->last+1)%MAX_VERTEX_NUM;
}

void BFSTraverse(MGragh *Gra)
{
    int i,j,k;
    Queue q;
    
    // 初始化
    for (i=0; i<Gra->VertexNum; i++){
        visit[i] = 0;
    }

    initQueue(&q);
    for (i=0; i<Gra->VertexNum; i++){
        if (visit[i] == 0){
            visit[i] = 1;
            EnQueue(&q,i);

            while(!QueueEmpty(&q)){
                DeQueue(&q,&k);
                printf("%s",Gra->Vertex[k].name);
                for (j=0; j<Gra->VertexNum; j++){
                    if (Gra->Edge[k][j] == 1 && visit[j] == 0){
                        visit[j] = 1;
                        EnQueue(&q,j);
                    }
                }
            }
            printf("
");
        }
    }
}

int main()
{
    MGragh g;
    CreateMGragh(&g);
    
    printf("DFS:");
    DFSTraverse(&g);
    printf("BFS:");
    BFSTraverse(&g);
    
    return 0;
}

测试用例与结果：