实验题6.2 实现图的遍历算法

【实验目的】

（1）巩固所学的有关图的基本知识；

（2）熟练掌握图的存储结构；

（3）熟练掌握图的两种遍历算法。

【实验准备】

（1）阅读教材中图的遍历相关内容；

（2）熟悉图的遍历算法。

【实验要求】

（1）采用函数调用的方式完成；

（2） 文件funp6-2.cpp的作用是完成图的深度优先遍历DFS和广度优先遍历BFS操作；

（3）实验提交必须有完整正确的程序以及程序运行结果的截图。

【实验内容】

编写一个程序，实现下图的遍历算法。（深度优先遍历DFS和广度优先遍历BFS）

#include <stdio.h>
#include <malloc.h>

#define INF     32767               
#define MAXV    100                 

typedef char InfoType;

typedef struct
{
    int no;                        
    InfoType info;                  
}VertexType;                       

typedef struct
{
    int edges[MAXV][MAXV];          
    int n;                          
    int e;                          
    VertexType vexs[MAXV];          
}MatGraph;                         


typedef struct ArcNode
{
    int adjvex;                     
    struct ArcNode* nextarc;        
    int weight;                     
}ArcNode;                           

typedef struct VNode
{
    InfoType info;                  
    int cnt;                        
    ArcNode* firstarc;              
}VNode;                             

typedef struct
{
    VNode adjlist[MAXV];            
    int n;                          
    int e;                         
}AdjGraph;                         


void CreateMat(MatGraph& g, int A[MAXV][MAXV], int n, int e)
{
    int i, j;

    g.n = n;
    g.e = e;
    for (i = 0; i < g.n; i++)
        for (j = 0; j < g.n; j++)
            g.edges[i][j] = A[i][j];
}


void DispMat(MatGraph g)
{
    int i, j;

    for (i = 0; i < g.n; i++)
    {
        for (j = 0; j < g.n; j++)
        {
            if (g.edges[i][j] != INF)
                printf("%4d", g.edges[i][j]);
            else
                printf("%4s", "∞");
        }
        printf("\n");
    }
}


void CreateAdj(AdjGraph*& G, int A[MAXV][MAXV], int n, int e)
{
    int i, j;
    ArcNode* p;

    G = (AdjGraph*)malloc(sizeof(AdjGraph));
    for (i = 0; i < n; i++)                              
    {
        G->adjlist[i].firstarc = NULL;
    }

    for (i = 0; i < n; i++)                              
    {
        for (j = n - 1; j >= 0; j--)
        {
            if (A[i][j] != 0 && A[i][j] != INF)          
            {
                p = (ArcNode*)malloc(sizeof(ArcNode)); 
                p->adjvex = j;                          
                p->weight = A[i][j];                    
                p->nextarc = G->adjlist[i].firstarc;    
                G->adjlist[i].firstarc = p;
            }
        }
    }
    G->n = n;
    G->e = e;
}


void DispAdj(AdjGraph* G)
{
    ArcNode* p;

    for (int i = 0; i < G->n; i++)
    {
        p = G->adjlist[i].firstarc;
        printf("顶点%d: ", i);
        while (p != NULL)
        {
            printf("%3d[%d]->", p->adjvex, p->weight);  
            p = p->nextarc;
        }
        printf("∧\n");
    }
}


int visited[MAXV];                                  


void DFS(AdjGraph* G, int v)                        
{
    ArcNode* p;

    printf("%3d", v);
    visited[v] = 1;                                 
    p = G->adjlist[v].firstarc;                     
    while (p != NULL)
    {
        if (visited[p->adjvex] == 0)                 
            DFS(G, p->adjvex);
        p = p->nextarc;                             
    }
}


void DFS1(AdjGraph* G, int v)                       
{
    ArcNode* p;
    int st[MAXV];                                   
    int top = -1;                                   
    int i;
    int x;
    int adjvex;                                    

    for (i = 0; i < G->n; i++)                       
    {
        visited[i] = 0;
    }
    printf("%3d", v);                               
    visited[v] = 1;                                
    top++;
    st[top] = v;                                    
    while (top > -1)                                 
    {
        x = st[top];                                
        p = G->adjlist[x].firstarc;                 
        while (p != NULL)
        {
            adjvex = p->adjvex;                     
            if (visited[adjvex] == 0)                
            {
                printf("%3d", adjvex);              
                visited[adjvex] = 1;                
                top++;                              
                st[top] = adjvex;
                break;                              
            }
            p = p->nextarc;                         
        }
        if (p == NULL)                               
            top--;
    }
    printf("\n");
}


void BFS(AdjGraph* G, int v)                        
{
    ArcNode* p;
    int graph_queue[MAXV], queue_front = 0, queue_rear = 0; 
    int visited[MAXV];                                      
    int i;
    int adjvex;

    for (i = 0; i < G->n; i++)
    {
        visited[i] = 0;                                     
    }
    printf("%3d ", v);                                     
    visited[v] = 1;                                        
    queue_rear = (queue_rear + 1) % MAXV;
    graph_queue[queue_rear] = v;                           
    while (queue_front != queue_rear)                      
    {
        queue_front = (queue_front + 1) % MAXV;
        adjvex = graph_queue[queue_front];                 
        p = G->adjlist[adjvex].firstarc;                    
        while (p != NULL)
        {
            if (visited[p->adjvex] == 0)                    
            {
                printf("%3d ", p->adjvex);                 
                visited[p->adjvex] = 1;                    
                queue_rear = (queue_rear + 1) % MAXV;       
                graph_queue[queue_rear] = p->adjvex;
            }
            p = p->nextarc;                                 
        }
    }
    printf("\n");
}

int main(void)
{
    AdjGraph* G;
    int n = 6;                                  
    int e = 10;                                 
    int A[MAXV][MAXV] = {
        {0, 9, 10, INF, INF, INF}, {9, 0, 7, 5, INF, INF},
        {10, 7, 0, INF, 6, 7}, {INF, 5, INF, 0, 11, INF},
        {INF, INF, 6, 11, 0, 8}, {INF, INF, 7, INF, 8, 0}
    };

    CreateAdj(G, A, n, e);
    printf("图的邻接表:\n");
    DispAdj(G);
    printf("从顶点0开始的DFS(递归算法):\n");
    DFS(G, 0);
    printf("\n");
    printf("从顶点0开始的DFS(非递归算法):\n");
    DFS1(G, 0);
    printf("从顶点0开始的BFS:\n");
    BFS(G, 0);



    return 0;
}