图的遍历（BFS，DFS）

最新推荐文章于 2022-06-06 20:21:02 发布

原创最新推荐文章于 2022-06-06 20:21:02 发布 · 869 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#队列 #算法 #数据结构 #图

数据结构专栏收录该内容

18 篇文章

订阅专栏

本文介绍了如何使用C++以邻接表形式创建无向图，并详细讲解了深度优先搜索（DFS）和广度优先搜索（BFS）的递归实现。通过实例展示了如何构造图结构及遍历算法在实际问题中的应用。

以邻接表的形式创建图：

#include <bits/stdc++.h>
using namespace std;
typedef int vtype;
typedef struct node //非头节点
{
    int num;
    struct node *next;
} anode;
typedef struct pnode //每行的头节点
{
    vtype data;
    anode *firstarc;
    int out, in, du;
} vnode;
vnode G[100];
int i = 0, j = 0;
int m = 0, n = 0;             //m点个数,n是边
void createajlist1(vnode G[]) //无向图的建立邻接表
{
    scanf("%d%d", &m, &n);
    int DATA;
    for (i = 1; i <= m; i++) //点的信息
    {
        scanf("%d", &DATA);
        G[i].data = DATA;
        G[i].firstarc = NULL; //顶点信息初始化
    }
    while (n--)
    {
        scanf("%d%d", &i, &j);
        G[i].out++, G[j].in++;
        G[j].out++, G[i].in++;
        anode *p;
        anode *q;
        p = new anode;//无向图连接两次，彼此都要连接，若为有向图，只连接一次。
        q = new anode;
        p->num = j;
        p->next = G[i].firstarc;
        G[i].firstarc = p;
        q->num = i;
        q->next = G[j].firstarc;
        G[j].firstarc = q;
    }
}
void printAlist(vnode G[]) //输出邻接表
{
    for (int i = 1; i <= m; i++)
    {
        printf("%d:", G[i].data);
        anode *p = G[i].firstarc;
        while (p != NULL)
        {
            printf("%d ", p->num);
            p = p->next;
        }
        printf("\n");
    }
}

递归形式的深度优先搜索：

int visited[100];
void resetvisited(int visited[]) //重置访问数组
{
    for (int i = 0; i < 100; i++)
    {
        visited[i] = 0;
    }
}
void DFS(vnode G[], int v) //递归深搜
{
    int w;
    printf("v%d ", G[v].data);
    visited[v] = 1;
    anode *p = G[v].firstarc;
    while (p != NULL)
    {
        w = p->num;
        if (visited[w] != 1)
            DFS(G, w);//向深处递归访问
        p = p->next; //
    }
}

递归形式的广度优先搜索：

int visited[101];
void resetvisited(int visited[]) //重置访问数组
{
    for (int i = 0; i < 100; i++)
    {
        visited[i] = 0;
    }
}
int head = 1, tail = 1;
void inqueue(int q[], int v) //入队
{
    q[tail] = v;
    tail++;
}
int outqueue(int q[]) //出队
{
    int num = q[head];
    head++;
    return num;
}
int isempty(int q[]) //空否
{
    if (q[head] == q[tail])
        return 1;
    else
    {
        return 0;
    }
}
void BFS(vnode G[], int v) //递归广搜
{
    int queu[101], w, u;
    printf("v%d ", G[v].data);
    visited[v] = 1;
    for (int i = 1; i <= 100; i++)//清空队列
    {
        queu[i] = 0;
    }
    inqueue(queu, v);
    while (isempty(queu) != 1)//队列空即结束
    {
        u = outqueue(queu);//出队一个元素
        anode *p = G[u].firstarc;
        while (p != NULL)//访问后续节点，并将其进队
        {
            w = p->num;
            if (visited[w] != 1)
            {
                printf("v%d ", G[w].data);
                inqueue(queu, w);
                visited[w] = 1;
            }
            p = p->next;
        }
    }
}