邻接矩阵 + 深度优先遍历 + 广度优先遍历

 

 

/**
　　知识点：(有向图)
　　　　强连通图的邻接矩阵存储图；
　　　　强连通图的深度优先遍历(递归方式实现)
        强连通图的广度优先遍历(递归+非递归实现)
*/
#include <stdio.h>
#include <string.h>
#define N 5
#define ARC 100
int visit[ARC],visitQ[ARC];
typedef struct {
    char vex[ARC][N];///顶点
    int arc[ARC][ARC];
    int numv,nume;///顶点,边的个数
}Graph;
int getIndex(Graph& G,char s[]){
    for(int i = 0; i < G.numv; i++){
        if(strcmp(s,G.vex[i]) == 0)
            return i;
    }
    return -1;
}
void create(Graph& G){
    printf("请分别输入顶点和边的个数:
");
    scanf("%d%d",&G.numv,&G.nume);
    printf("输入图的顶点信息：
");
    for(int i = 0; i < G.numv; i++)
        scanf("%s",G.vex[i]);
    printf("请输入边的信息:
");
    ///初始化数组G.arc
    for(int i = 0; i < G.numv; i++)
        for(int j = 0; j < G.numv; j++)
            G.arc[i][j] = 0;
    char s[N],e[N];
    int i = 0,u,v;
    while(i < G.nume){
        scanf("%s%s",s,e);
        u = getIndex(G,s);
        v = getIndex(G,e);
        ///假设输入的起始和终止顶点都存在
        G.arc[u][v] = 1;
        i++;
    }
}
///输出矩阵
void output(Graph G){
    printf("    ");
    for(int i = 0; i < G.numv; i++)
        printf("%4s",G.vex[i]);
    printf("
");
    for(int i = 0; i < G.numv; i++){
        for(int j = -1; j < G.numv; j++){
            if(j == -1)
                printf("%4s",G.vex[i]);
            else{
                printf("%4d",G.arc[i][j]);
            }
        }
        printf("
");
    }
}

///查找图G中位序为s的第一个邻接点
int firstVex(Graph G,int s){
    for(int i = 0; i < G.numv; i++){
        if(G.arc[s][i] == 1)
            return i;
    }
    return -1;
}
///返回顶点s的（相对于w的）下一个邻接顶点
///若w是s的最后一个邻接顶点，则返回-1
int nextVex(Graph G,int s,int w){
    for(int i = w+1; i < G.numv; i++){
        if(G.arc[s][i] == 1)
            return i;
    }
    return -1;
}
///递归法 深度优先遍历
void dfs(Graph G,int s){///从位置为s的顶点开始遍历
    for(int w=firstVex(G,s);w!=-1;w=nextVex(G,s,w)){
        if(!visit[w]){
            printf("%4s",G.vex[w]);
            visit[w] = 1;
            dfs(G,w);
        }
    }
}

int r[ARC],F=0,R=0;
///递归法 广度优先遍历
void bfs(Graph G,int s){
    ///判断根节点是否已经遍历
    if(!visitQ[s]){
        printf("%4s",G.vex[s]);
        visitQ[s] = 1;
    }
    ///遍历根节点s的邻接点

    for(int i = 0; i < G.numv; i++){
        if(!visitQ[i] && G.arc[s][i]){
            printf("%4s",G.vex[i]);
            visitQ[i] = 1;
            r[R++] = i;
        }
    }
    ///递归遍历s的邻接点
    if(F<R) bfs(G,r[F++]);
}

///广度优先遍历(非递归)
int q[2*ARC],Fq=0,Rq=0;
int visit_q[2*ARC];
void bfs_ND(Graph G,int s){
    int node;
    q[Rq++] = s;
    while(Fq < Rq){
        node = q[Fq++];
        if(!visit_q[node]){
            printf("%4s",G.vex[node]);
            visit_q[node] = 1;
            ///将顶点node的邻接点入队列
            for(int i = 0; i < G.numv; i++){
                if(!visit_q[i] && G.arc[node][i])
                    q[Rq++] = i;
            }
        }
    }
}

int main(void){
    Graph G;
    create(G);
    output(G);
    printf("请输入遍历的起始顶点:
");
    char s[N];
    scanf("%s",s);
    for(int i = 0; i < G.numv; i++)
        visit[i] = visit_q[i] = 0;
    printf("递归 深度优先遍历:
");
    printf("%4s",s); visit[getIndex(G,s)] = 1;
    dfs(G,getIndex(G,s));
    printf("
递归 广度优先遍历:
");
    bfs(G,getIndex(G,s)); printf("
");
    printf("非递归 广度优先遍历:
");
    bfs_ND(G,getIndex(G,s)); printf("
");
    return 0;
}

测试数据：

8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v2 v4
v2 v5
v3 v6
v3 v7
v4 v8
v5 v8
v7 v6
v1