图的存储与遍历

内容

利用邻接矩阵描述示例图，编写程序输出示例图的深度优先搜索和广度优先搜索的遍历序列。

具体步骤如下：

1. 将图的邻接矩阵描述为一个二维数组，并将该数组定义为全局变量，以便数据的传递；
2. 定义一个队列，在广度优先搜索时，该队列存储已被访问的路径长度为1，2，…的顶点；
3. 定义访问函数visit()、深度优先搜索函数DFS()和广度优先搜索函数BFS()；
4. 主函数实现各函数的调用。

实验代码

下面展示一些 内联代码片。

#include <stdio.h>

#define MAX 100                         
#define TRUE 1
#define FALSE 0
typedef char VerTexType;                //顶点类型
typedef int ArcType;                    //权值类型
typedef int Bool;
Bool visited[MAX];

//图的邻接矩阵存储表示
typedef struct {
    
    
    VerTexType vexs[MAX];               
    ArcType arc[MAX][MAX];              
    int vexnum, arcnum;                
}MGraph; 

//队列的顺序存储结构
typedef struct {
    
    
    int data[MAX];
    int front, rear;
}Queue;
//========================================
void InitQueue(Queue *Q);
void EnQueue(Queue *Q, int e);
Bool QueueEmpty(Queue *Q);
void DeQueue(Queue *Q, int *e);
void CreateMGraph(MGraph *G);
void DisMGraph(MGraph *G);
void DFS(MGraph G, int i);
void DFSTraverse(MGraph G);
void BFS(MGraph *G);

void InitQueue(Queue *Q)
{
    
    
    Q->front = Q->rear = 0;
}
void EnQueue(Queue *Q, int e)
{
    
    
    if ((Q->rear+1)%MAX == Q->front)
        return ;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear+1)%MAX;
}
Bool QueueEmpty(Queue *Q)
{
    
    
    if (Q->front == Q->rear)
        return TRUE;
    else
        return FALSE;
}
void DeQueue(Queue *Q, int *e)
{
    
    
    if (Q->front == Q->rear)
        return ;
    
    *e = Q->data[Q->front];
    Q->front = (Q->front+1)%MAX;
}
//=============================================
void CreateMGraph(MGraph *G)                    //建¨立ⅰ?图?的?邻ⅷ?接ó矩?阵ó
{
    
    
    int i, j, k, w;

    printf("输入顶点数和边数: ");
    scanf("%d%d", &G->vexnum,&G->arcnum);
    fflush(stdin);

    //printf("==============================\n");
    printf("输入各个顶点信息:\n");
    for (i=0; i<G->vexnum; ++i)
    {
    
    
        printf("顶点%d: ",i+1);
        scanf("%c", &G->vexs[i]);
        fflush(stdin);
    }

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

    printf("==============================\n");
    for (k=1; k<=G->arcnum; ++k)
    {
    
    
        printf("输入当前边两端点的下标值： ");
        scanf("%d%d", &i,&j);
        G->arc[i][j] = 1;
        G->arc[j][i] = G->arc[i][j];
    }
}
void DisMGraph(MGraph *G)                        //输出
{
    
    
    int i, j, k;
    k = G->vexnum;
    for (i=0; i<k; ++i)
    {
    
    
        for (j=0; j<k; ++j)
        {
    
    
            printf("%5d ", G->arc[i][j]);
        }
        putchar('\n');
    }
}
//==============================================
void DFS(MGraph G, int i)                   //图的深度优先遍历
{
    
    
    int j;
    visited[i] = TRUE;
    printf("%c ",    G.vexs[i]);

    for (j=0; j<G.vexnum; ++j)
    {
    
    
        if (G.arc[i][j]!=0  &&  !visited[j])
            DFS(G, j);
    }
}
void DFSTraverse(MGraph G)
{
    
    
    int i;
    for (i=0; i<G.vexnum; ++i)
        visited[i] = FALSE;

    for (i=0; i<G.vexnum; ++i)
    {
    
    
        if (!visited[i])
            DFS(G, i);
    }

}
void BFS(MGraph *G)                 //图的广度优先遍历
{
    
    
    int i, j;
    Queue Q;

    for (i=0; i<G->vexnum; ++i)
        visited[i] = FALSE;

    InitQueue(&Q);

    for (i=0; i<G->vexnum; ++i)
    {
    
    
        if (!visited[i])
        {
    
    
            visited[i] = TRUE;
            printf("%c ", G->vexs[i]);
            EnQueue(&Q, i);

            while (!QueueEmpty(&Q))
            {
    
    
                DeQueue(&Q, &i);
                for (j=0; j<G->vexnum; ++j)
                {
    
    
                    if (!visited[j] && G->arc[i][j]!=0)
                    {
    
    
                        visited[j] = TRUE;
                        printf("%c ", G->vexs[j]);
                        EnQueue(&Q, j);
                    }
                }
            }
        }
    }
}
//========================================
int main(){
    
    
    MGraph G;

    CreateMGraph(&G);

    printf("\n图的深度优先遍历为: ");
    DFSTraverse(G);    

    printf("\n图的广度优先遍历为: ");
    BFS(&G);

    printf("\n\n\n");

    return 0;
}

实验结果