数据结构—连通图的遍历—DFS和BFS

/*
图的遍历。
*/
#include <iostream>
#include <stdio.h>
#include <malloc.h>
#define MAXV 50
typedef int InfoType;
using namespace std;

//邻接表类型
typedef struct ANode
{
    int adjvex;             //该边的编号
    struct ANode *nextarc;  //指向下一条边的信息
    InfoType info;          //该弧的相关信息,这里用于存放权值
} ArcNode;                  //边节点的类型

typedef struct Vnode
{
    ArcNode *firstarc;      //指向第一条边
} VNode;                    //邻接表头节点类型

typedef VNode AdjList[MAXV];
typedef struct
{
    AdjList adjlist;       //邻接表
    int n,e;               //图中顶点数n和边数e
} ALGraph;                 //完整的图邻接表类型

void ArrayToList(int *Arr, int n, ALGraph *&G)  //用普通数组构造图的邻接表
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    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 (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}

/*
深度优先遍历：
从图的某个初始顶点v出发，然后选择一个与顶点v相邻接且没有被访问过的顶点w为初始顶点，
再从w出发进行深度优先遍历，直到图中与当前顶点v邻接的所有顶点都被访问过为止。
*/
int visited[MAXV];
void DFS(ALGraph *G,int v)
{
    ArcNode *p;
    visited[v]=1;          //置已访问标记
    cout<<v;               //输出被访问顶点的编号
    p=G->adjlist[v].firstarc;  //p指向顶点v的第一个邻接点
    while(p!=NULL)
    {
        if(visited[p->adjvex]==0)   //若p->adjvex顶点未被访问，递归访问它
            DFS(G,p->adjvex);
        p=p->nextarc;               //p指向顶点v的下一个邻接点
    }
}

/*
广度优先遍历：
首先访问初始顶点v,接着访问顶点v的所有未被访问过的邻接点v1,v2,...,vt，再按照v1,v2,...,vt的次序，
访问每一个顶点的所有未被访问过的邻接点，以此类推，直到图中所有和初始顶点v有路径相通的顶点都被访问过为止。
*/
void BFS(ALGraph *G,int v)
{
    ArcNode *p;
    int queue[MAXV],front=0,rear=0;
    int visited[MAXV];
    int w,i;
    for(i=0;i<G->n;i++)       //访问标志数组初始化
        visited[i]=0;
    cout<<v;                  //输出被访问顶点的编号
    visited[v]=1;
    rear=(rear+1)%MAXV;
    queue[rear]=v;            //v进队
    while(front!=rear)
    {
        front=(front+1)%MAXV;
        w=queue[front];       //出队并赋给w
        p=G->adjlist[w].firstarc;       //找顶点w的第一个邻接点
        while(p!=NULL)
        {
            if(visited[p->adjvex]==0)       //若当前邻接顶点未被访问
            {
                cout<<p->adjvex;            //访问相邻顶点
                visited[p->adjvex]=1;
                rear=(rear+1)%MAXV;         //该顶点入队
                queue[rear]=p->adjvex;
            }
            p=p->nextarc;                  //找顶点w的下一个邻接点
        }
    }
    cout<<endl;
}
int main()
{
    int i;
    ALGraph *G;
    int A[5][5]=
    {
        {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}
    };
    ArrayToList(A[0], 5, G);

    for(i=0; i<MAXV; i++)
        visited[i]=0;
    printf(" 由2开始深度遍历:");
    DFS(G, 2);
    printf("\n");
    for(i=0; i<MAXV; i++) visited[i]=0;
    printf(" 由0开始深度遍历:");
    DFS(G, 0);
    printf("\n");
    cout<<" 由2开始广度遍历:";
    BFS(G, 2);
    cout<<" 由0开始广度遍历:";
    BFS(G, 0);
    return 0;
}

测试用例：

运行结果：