[数据结构]图的深度优先搜索（DFS）和广度优先搜索（BFS）（通俗易懂）

最新推荐文章于 2022-07-05 00:20:22 发布

久忆凉

最新推荐文章于 2022-07-05 00:20:22 发布

阅读量569

点赞数

本文为博主原创文章，转载时务必注明其出处。

本文链接：https://blog.csdn.net/Honeycomb_1/article/details/79947355

版权

数据结构与算法专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一、深度优先搜索（DFS，Depth First Search）

深度优先搜索的主要思想：首先从一个未走过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有被访问过的顶点时，则回到上一个顶点，继续访问别的未被访问过的顶点，直到所有的顶点都被访问过。（不撞南墙不回头）

DFS遍历图解过程如下：

1、DFS邻接矩阵核心代码实现（可以链表实现，以下是数组实现）：

bool book[1]=true;
int e[][];///邻接矩阵
int sum=1;
void DFS(int u){///从顶点1出发
    printf("%d ",u);
    sum++;
    if(sum==n) return;
    for(int v=1;v<=n;v++){
        if(e[u][v]==1&&!book[v]){
          book[v]=ture;
          dfs(v);  
        }
    }
}

2、DFS邻接表核心代码实现：

（1）链式指针

void dfs(ALGraph *G,int u){///从顶点1出发
    cout<<G->adj[u].data<<" ";
    visited[u]=true;
    EdgeNode *p=G->adj[u].firstedge;
    while(p){
        u=p->adjvex;///顶点的下标
        if(!visited[u]) dfs(G,u);
        p=p->next;
    }
}

（2）一种非常容易理解的前向星DFS：

bool visited[maxn]={0};

void dfs(int x){
    visited[x]=true;
    printf("%d\n",x);
    for(int i=head[x];i!=-1;i=e[i].next)
       if(！visited[e[i].to])
         dfs(e[i].to);
}

二、广度优先搜索（BFS，Breadth First Search）

广度优先遍历的主要思想：首先从一个未被访问过的顶点作为起始顶点，访问其所有相邻的顶点（邻接点），然后对每个相邻的顶点，再访问它们相邻的未被访问过的顶点，直到所有顶点都被访问过，遍历结束。（一层一层地搜，先搜顶点的所有邻接点，再搜顶点的邻接点的所有邻接点）

BFS遍历图解过程如下：

下面是一个无向图加入队列的简易过程：

1、BFS邻接矩阵核心代码实现：

int head=1,tail=1;///初始化队头和队尾
int que[tail++]=1;///从1号顶点出发，1号顶点加入队列
bool book[1]=true;
int e[][];///邻接矩阵

int cur;///当前正在访问的顶点编号
while(head<tail){
    cur=que[head];
    for(int i=1;i<=n;i++){
        if(e[cur][i]&&!book[i]){///访问顶点的邻接点
            que[tail]=i;
            tail++;
            book[i]=true;///标记访问过的顶点
        }
        if(tail>n) break;///如果tail大于n，表明所有顶点都已经被访问了
    }
    head++;///继续下一个顶点
}

2、BFS邻接表核心代码实现：

（1）

void bfs(ALGraph *G,int x){
    que.push(G->adj[x].data);
    cout<<que.front()<<" ";
      que.pop();
    visited[x]=true;
    while(!que.empty()){
      EdgeNode *p=G->adj[x].firstedge;
      while(p!=NULL){
          if(!visited[p->adjvex]){
            que.push(G->adj[p->adjvex].data);
            cout<<que.front()<<" ";
            que.pop();
            visited[p->adjvex]=true;
          }
          p=p->next;
      }
    }
}

（2）一种非常容易理解的前向星BFS：

bool visited[maxn];

void BFS(int x){
     int queue[maxn];
     int iq;
    queue[iq++]=x;
    for(int i=0;i<iq;i++){
       printf("%d\n",queue[i]);
       for(int k=head[queue[i]];k!=-1;k=e[k].next)
          if(!visited[e[k].to]) queue[iq++] = e[k].to;
    }
}

三、完整代码实现：

1、字符型顶点代码实现：

#include<iostream>
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<queue>
using namespace std;
#define N 100
typedef struct EdgeNode{///边表结点
    int adjvex;///邻接点域，存储该顶点对应的下标
    int weight;///权值
    EdgeNode *next;///链域，指示下一条边或弧，指向下一个邻接点
}EdgeNode;

typedef struct{///顶点结点
  char data;///顶点信息
  struct EdgeNode *firstedge;///指向第一个邻接点，边表头指针
}AdjList[N];

typedef struct ALGraph{
   AdjList adj;
   int n,m;///顶点数和边数
}ALGraph;
queue<char> que;
bool visited[N];
void GreatALGraph(ALGraph *G){///图的邻接表的结构
   EdgeNode *p,*q;
   cin>>G->n>>G->m;
   getchar();
   for(int i=0;i<G->n;i++){
    cin>>G->adj[i].data;///字符类型的顶点
    G->adj[i].firstedge=NULL;
   }
   getchar();
   for(int k=0;k<G->m;k++){
     char u,v;
     EdgeNode *p,*q;
    cin>>u>>v;
    int i,j;
    for(int s=0;s<G->n;s++){
        if(u==G->adj[s].data)
                i=s;
        if(v==G->adj[s].data)
                j=s;
   }

   p=(EdgeNode *)malloc(sizeof(EdgeNode));
   p->adjvex=j;
   p->next=G->adj[i].firstedge;
   G->adj[i].firstedge=p;

   q=(EdgeNode *)malloc(sizeof(EdgeNode));//从链表头插入
   q->adjvex=i;
   q->next=G->adj[j].firstedge;
   G->adj[j].firstedge=q;
 }
}
void bfs(ALGraph *G,int x){
    que.push(G->adj[x].data);
    cout<<que.front()<<" ";
      que.pop();
    visited[x]=true;
    while(!que.empty()){
      EdgeNode *p=G->adj[x].firstedge;
      while(p!=NULL){
          if(!visited[p->adjvex]){
            que.push(G->adj[p->adjvex].data);
            cout<<que.front()<<" ";
            que.pop();
            visited[p->adjvex]=true;
          }
          p=p->next;
      }
    }
}
void dfs(ALGraph *G,int u){///从顶点1出发
    cout<<G->adj[u].data<<" ";
    visited[u]=true;
    EdgeNode *p=G->adj[u].firstedge;
    while(p){
        u=p->adjvex;///顶点的下标
        if(!visited[u]) dfs(G,u);
        p=p->next;
    }
}
int main(){
    ALGraph *G;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    GreatALGraph(G);
    puts("深度优先搜索：");
    memset(visited,false,sizeof(visited));
    for(int i=0;i<G->n;i++)
        if(!visited[i]) dfs(G,i);
    puts();
    puts("广度优先搜索：");
    memset(visited,false,sizeof(visited));
    for(int i=0;i<G->n;i++)
        if(!visited[i]) bfs(G,i);
}

2、数据型顶点代码实现

///基于链式前向星原理
///本代码修改于http://ddrv.cn/a/46849
#include<iostream>
#include<cstring>
#include<queue>
#include<stdio.h>
using namespace std;
#define maxn 100
int head[maxn];
bool vis[maxn];///
bool book[maxn];
queue<int> que;
struct EdgeNode
{
    int to;///这条边到达的点
    int w;///边权值
    int next;///下一条边的编号
}e[N];
int k;
void init()
{
    int i;
    memset(head,-1,sizeof(head));
    memset(vis,false,sizeof(vis));
    memset(book,false,sizeof(vis));
    k = 0;
}


void add(int i,int j,int w)///添加边
{
    e[k].w = w;///边权值
    e[k].to = j;///下一条边的编号
    e[k].next = head[i];
    head[i] = k++;
}

void traver(int m)///遍历边集合
{
    int i,p;
    for(p=1;p<=m;p++)
    for(i=head[p];i!=-1;i=e[i].next)
    {
        printf("%d %d %d\n",p,e[i].to,e[i].w);
    }
}

void dfs(int x)///深搜
{
    int i;
    vis[x] = true;
    printf("%d\n",x);
    for(i=head[x];i!=-1;i=e[i].next)
        if(!vis[e[i].to])
        {
            dfs(e[i].to);
        }
}

void bfs(int x)///广搜
{
    que.push(x);
    book[x] = true;
    int i,k;
    while(!que.empty())
    {
        int x = que.front();
        que.pop();
        printf("%d\n",x);
        for(k=head[x];k!=-1;k=e[k].next)
        {
            if(!book[e[k].to])
            {
                que.push(e[k].to);
                book[e[k].to] = true;
            }
        }
    }
}

int main()
{
    int m,n;
    int i;
    int u,v,w;
    scanf("%d%d",&m,&n); //m个点,n条边
    init();
    for(i=0;i<n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    printf("traver result:\n");
    traver(m);
    printf("-------------------------------\n");
    printf("深搜:\n");
    dfs(1);
    printf("-------------------------------\n");
    printf("广搜:\n");
    bfs(1);
    return 0;
}

四、经典例题

一矩形阵列由数字0到9组成,数字1到9代表细胞,细胞的定义为沿细胞数字上下左右若还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。（1<=m,n<=100）?

输入：整数m,n(m行，n列)矩阵

输出：细胞的个数

输入样例#1：

输出样例#1：

//DFS
#include <stdio.h>
#include<string.h>
#include <iostream>
using namespace std;
int n,m;
char a[106][106];
bool vis[106][106];
/*上下左右方法1
void dfs(int i,int j)
{
  vis[i][j]=true;
  //int h=a[i][j]-'1'+1;
  if(i+1<=n&&!vis[i+1][j]&&a[i+1][j]!='0') dfs(i+1,j);
  if(j+1<=m&&!vis[i][j+1]&&a[i][j+1]!='0')  dfs(i,j+1);
  if(i-1>=1&&!vis[i-1][j]&&a[i-1][j]!='0')  dfs(i-1,j);
  if(j-1>=1&&!vis[i][j-1]&&a[i][j-1]!='0') dfs(i,j-1);
}
*/
int xx[5]={0,1,0,-1,0};//注意0~4J就为{1,0，-1,0}；
int yy[5]={0,0,1,0,-1};//
void dfs(int i,int j)
{
  for(int k=1;k<5;k++)
      if((i+xx[k]>=1)&&(i+xx[k]<=n)&&(j+yy[k]>=1)&&(j+yy[k]<=m)&&(a[i+xx[k]][j+yy[k]]!='0')&&(!vis[i+xx[k]][j+yy[k]]))
      {
          vis[i+xx[k]][j+yy[k]]=true;
          dfs(i+xx[k],j+yy[k]);
      }
}
int main()
{
    int sum;
    memset(vis,false,sizeof(vis));
  scanf("%d%d",&n,&m);
  for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
         cin>>a[i][j];
    sum=0;
   for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
      if(a[i][j]!='0'&&!vis[i][j])
      {
       sum++;
       vis[i][j]=true;
       dfs(i,j);
      }
   printf("%d",sum);
   return 0;
}

BFS（一层层的搜）

#include<stdio.h>
#include <string.h>
#include <queue>
#include <iostream>
using namespace std;
int n,m,tnt=0;
int xx[4]={1,0,-1,0};
int yy[4]={0,1,0-1};
bool a[106][106];
void bfs(int i,int j)
{
    queue<int>qx,qy;
    tnt++;
    int x,y;
    qx.push(i);
    qy.push(j);
    a[i][j]=false;
    while(!qx.empty())
    {
      for(int k=0;k<4;k++)
      {
         x=qx.front()+xx[k];
         y=qy.front()+yy[k];
         if(x>=1&&x<=n&&y>=1&&y<=m&&a[x][y])
         {
         qx.push(x);
         qy.push(y);
         a[x][y]=false;
         }
      }
      qx.pop(),qy.pop();
    }
}
int main ()
{
   string s;
   scanf("%d%d",&n,&m);
   for(int i=1;i<=n;i++)
   {
      cin>>s;
      for(int j=0;j<m;j++)//注意s起始是从0开始的
       if(s[j]=='0') a[i][j+1]=false;
       else a[i][j+1]=true;
   }
   for(int i=1;i<=n;i++)
      for(int j=1;j<=m;j++)
        if(a[i][j])
           bfs(i,j);
   printf("%d",tnt);
   return 0;
}

四、参考资料

1、《啊哈算法》

2、《大话数据结构》

久忆凉

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[数据结构]图的深度优先搜索（DFS）和广度优先搜索（BFS）（通俗易懂）

一、深度优先搜索（DFS，Depth First Search）深度优先搜索的主要思想：首先从一个未走过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有被访问过的顶点时，则回到上一个顶点，继续访问别的未被访问过的顶点，直到所有的顶点都被访问过。（不撞南墙不回头）DFS遍历图解过程如下：1、DFS邻接矩阵核心代码实现（可以链表实现，以下是数组实现）：bool boo...
复制链接

扫一扫