56-图的遍历算法实现

深度优先（DFS）算法和广度优先（BFS）算法实现：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXV 5

#define N 5

typedef struct ANode
{
    int adjvex;                 //记录某顶点的邻接点
    struct ANode *nextarc;      //指向下一条边节点的指针

} ArcNode; //边节点类型

typedef int Vertex;

typedef struct Vnode
{
    Vertex data;            //存储顶点的信息
    ArcNode *firstarc;      //指向第一个边节点

} VNode; //表头节点类型


typedef VNode AdjList[MAXV];

typedef struct
{
    AdjList adjlist;        //邻接表，这其实是一个数组（顺序表）
    int n,e;            //记录顶点个数n，边数e

} ALGraph; //完整的图邻接表类型


//图的定义：邻接矩阵
typedef struct MGRAPH{
    int n;                  //顶点数
    int e;                  //边数
    int deges[MAXV][MAXV];  //邻接矩阵
} MGraph;


/*
将邻接矩阵转换成邻接表
MGraph *g：表示邻接矩阵
*/
ALGraph *MatToList(MGraph *g)
{
    int i;
    int j;
    ArcNode *p = NULL;
    ALGraph *G = (ALGraph *)malloc(sizeof(ALGraph));

    //给所有头节点的指针域置初值
    for(i = 0; i < g->n; i++)
    {
        G->adjlist[i].firstarc = NULL;
    }

    //根据邻接矩阵建立邻接表中节点
    for(i = 0; i < g->n; i++)
    {
        for(j = g->n - 1; j >= 0; j--)
        {
            if(g->deges[i][j] != 0)
            {
                p = (ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex = j;
                //采用头插法，插入邻接表
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
    G->n = g->n;
    G->e = g->e;

    return G;
}

//定义数组，算法执行前全置0
int visited[N] = {0};

//G表示给定的图，采用邻接表存储
//v表示起始点
void DFS(ALGraph *G , int v)
{
    ArcNode *p = NULL;
    int w;

    if(G == NULL)
    {
        return;
    }

    //置为已访问标记
    visited[v] = 1;
    //输出被访问顶点的编号
    printf("%d\t" , v);
    //p指向顶点v的第一条边的头节点
    p = G->adjlist[v].firstarc;
    while(p != NULL)
    {
        //如果顶点w没有被访问过，则递归访问
        w = p->adjvex;
        if(visited[w] == 0)
        {
            DFS(G,w);
        }
        //如果已经访问过，p则指向下一条边的头节点
        p = p->nextarc;
    }
}


//G表示给定的图，采用邻接表存储
//v表示起始点
void BFS(ALGraph *G , int v)
{
    ArcNode *p;
    int w,i;
    int queue[MAXV],front=0,rear=0;

    //定义存放节点的访问标志的visited数组，并全部初始化为0
    int visited[MAXV];
    for (i = 0; i < G->n; i++)
    {
        visited[i]=0;
    }


    //访问第一个顶点并入队，注意这里是采用的环形队列
    printf("%d\t",v);
    //标记为已访问
    visited[v]=1;
    rear=(rear+1)%MAXV;
    queue[rear]=v;

    //队列是否为空，否则取出队中未被访问的顶点
    while (front!=rear)
    {
        //取出队中顶点
        front=(front+1)%MAXV;
        w=queue[front];
        //获取邻接点（访问该顶点的所有未访问的邻接点并使之入队）
        p=G->adjlist[w].firstarc;
        while (p!=NULL)
        {   
            //这个邻接点是否已经访问
            if (visited[p->adjvex]==0)
            {
                //访问这个邻接点，并将该邻接点标记为已访问
                printf( "%d\t",p->adjvex);
                visited[p->adjvex]=1;

                //然后将邻接点入队
                rear=(rear+1)%MAXV;
                queue[rear]=p->adjvex;
            }
            //获取下一个邻接点
            p=p->nextarc;
        }
    }
}


int main(void)
{
    int i;
    int j;
    //转换成无向图的邻接矩阵
    int A[MAXV][MAXV] = {

                        {0,1,0,1,0},
                        {1,0,1,0,0},
                        {0,1,0,1,1},
                        {1,0,1,0,1},
                        {0,0,1,1,0}

                        };

    MGraph mg;
    ALGraph *ag = NULL;
    mg.n = 5;
    mg.e = 6;

    for(i = 0; i < MAXV; i++)
    {
        for(j = 0; j < MAXV; j++)
        {
            mg.deges[i][j] = A[i][j];
        }
    }

    //将邻接矩阵转换成邻接表
    ag = MatToList(&mg);

    if(ag == NULL)
    {
        printf("MatToList error\n");
    }

    printf("深度优先（DFS）遍历序列：");
    //以顶点2为起始点，开始遍历
    DFS(ag , 2);
    printf("\n\n");

    printf("广度优先（BFS）遍历序列：");
    //以顶点0为起始点，开始遍历
    BFS(ag, 0);
    printf("\n\n");

    return 0;
}
测试结果：
从程序的执行结果来看，和55-图的遍历（DFS和BFS）中的DFS算法和BFS算法遍历序列是一样的。
56-图的遍历算法实现

猜你喜欢
