广度优先遍历和深度优先遍历

最新推荐文章于 2021-04-09 11:04:14 发布
最新推荐文章于 2021-04-09 11:04:14 发布
阅读量596 收藏
点赞数
分类专栏： 数据结构 文章标签： graph network struct null matrix 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YHS_CODE/article/details/5649434
版权

/*=============================邻接矩阵的存储结构=============================*/
#include<stdio.h>

#define  OK                 1
#define  ERROR              -1
#define  TRUE               1
#define  FALSE              0
#define  ADJACENCY          1
#define  UNADJACENCY        0
#define  NETWORK_INFINITY   32767
#define  MAX_VERTEX_NUM     20

int visited[MAX_VERTEX_NUM];
typedef int VRType;
typedef int VertexType;
typedef char InfoType;

typedef enum{ DG,DN,UDG,UDN }GraphKind;
typedef struct ArcCell {
   VRType  adj;
   InfoType *info;
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct {
   VertexType  vexs[MAX_VERTEX_NUM];
   AdjMatrix   arcs;
   int         vexnum,arcnum;
   GraphKind   kind;
}AMGraph;

/*============================================================================*/
/*                                                                            */
/*                         顺   序   队  列                                   */
/*                                                                            */
/*============================================================================*/
typedef struct{
    int data;
}elemtype;

#define QUEUE_MAXSIZE 100
typedef struct{
    elemtype elem[QUEUE_MAXSIZE];
    int front ,rear;
    int length;
}QUEUE;

void queue_init(QUEUE *q)
{
   (*q).front=(*q).rear=-1; (*q).length=0;
}

int queue_empty(QUEUE *q)
{
   if((*q).length==0) return 1;
   else               return 0;
}

void queue_push(QUEUE *q,elemtype e)
{
   if((*q).length==QUEUE_MAXSIZE) { printf("QUEUE IS FULL"); return ;}
   (*q).rear=++(*q).rear%QUEUE_MAXSIZE;
   (*q).elem[(*q).rear]=e;
   (*q).length++;
   if((*q).length==1&&(*q).front==-1) (*q).front=0;
}

void queue_pop(QUEUE *q,elemtype *e)
{
   if((*q).length==0) { printf("QUEUE IS EMPTY"); return ;}
   *e=(*q).elem[(*q).front++];
   (*q).front=(*q).front%QUEUE_MAXSIZE;
   (*q).length--;
   if((*q).length==0) (*q).front=(*q).rear=-1;
}

void queue_gettop(QUEUE *q,elemtype *e)
{
   if((*q).length) *e=(*q).elem[(*q).front];
   else  printf("QUEUE IS EMPTY");
}

/*========================邻接矩阵的基本操作的实现============================*/

/*-----------------------1、 CreateGraph(&G,V,VR)-----------------------------*/
int CreateGraph( AMGraph *G )
{
   int choice;
   printf(" 1-Directed Graph          /n");
   printf(" 2-Directed Network        /n");
   printf(" 3-UnDirected Graph        /n");
   printf(" 4-UnDirected Network      /n/n");
   do{ if(choice<1||choice>4)printf(" Choose: ");scanf("%d",&choice);}
   while(choice<1||choice>4);
   G->kind = (GraphKind)(choice);

   switch(G->kind){
     case  DG+1: return CreateDG(G);
     case  DN+1: return CreateDN(G);
     case UDG+1: return CreateUDG(G);
     case UDN+1: return CreateUDN(G);
     default : return ERROR;
   }
}

int CreateDG( AMGraph *G )
{
   int IncInfo,i,j,k;    VertexType v1,v2;
   printf("/n/n The Graph's number of Vertex :"); scanf("%d",&(G->vexnum));
   printf(" The Graph's number of Arcnum :"); scanf("%d",&(G->arcnum));
   printf(" The Graph's incinfo:"); scanf("%d", &IncInfo);  printf("/n");
   /*顶点编号或者名称*/
   for(i = 0;i < G -> vexnum ;i ++){ printf(" The Graph's %d Vertex's NAME:",i+1); scanf("%d",(G->vexs)+i); }
   /*初始化邻接矩阵*/
   for(i=0;i< G->vexnum ;i++)
     for(j=0;j< G->vexnum ;j++){ (G->arcs)[i][j].adj = UNADJACENCY; (G->arcs)[i][j].info = NULL ; }
   /* 构造邻接矩阵 */
   for(k = 0;k < G -> arcnum;k ++){
     printf("/n The %d Arc ./n",k+1);
     printf(" The tail vertex:");do{ scanf("%d",&v1);if((v1<=0)||(v1>G->vexnum))printf(" ERROR/n The tail vertex:"); }while((v1<=0)||(v1>G->vexnum));
     printf(" The head vertex:");do{ scanf("%d",&v2);if((v2<=0)||(v2>G->vexnum))printf(" ERROR/n The head vertex:"); }while((v2<=0)||(v2>G->vexnum));
     i = LocateVex(*G,v1); j = LocateVex(*G,v2);
     (G->arcs)[i][j].adj = ADJACENCY;
     if(IncInfo){
       printf(" Enter %d arc's IncInfo:",k+1);
       scanf("%s",(G->arcs)[i][j].info ); fflush(stdin);
     }
     printf("/n");
   }
   return OK;
}

int CreateDN(AMGraph *G )
{
   int IncInfo,i,j,k;    VertexType v1,v2,w;
   printf("/n/n The Graph's number of Vertex :"); scanf("%d",&(G->vexnum));
   printf(" The Graph's number of Arcnum :"); scanf("%d",&(G->arcnum));
   printf(" The Graph's incinfo:"); scanf("%d", &IncInfo);  printf("/n");

   /*顶点编号或者名称*/
   for(i = 0;i < G -> vexnum ;i ++){ printf(" The Graph's %d Vertex's NAME:",i+1); scanf("%d",(G->vexs)+i); }
   /*初始化邻接矩阵*/
   for(i=0;i< G->vexnum ;i++)
     for(j=0;j< G->vexnum ;j++){ (G->arcs)[i][j].adj = NETWORK_INFINITY; (G->arcs)[i][j].info = NULL ; }
   /* 构造邻接矩阵 */
   for(k = 0;k < G -> arcnum;k ++){
     printf("/n The %d Arc ./n",k+1);
     printf(" The tail vertex:");do{ scanf("%d",&v1);if((v1<=0)||(v1>G->vexnum))printf(" ERROR/n The tail vertex:"); }while((v1<=0)||(v1>G->vexnum));
     printf(" The head vertex:");do{ scanf("%d",&v2);if((v2<=0)||(v2>G->vexnum))printf(" ERROR/n The head vertex:"); }while((v2<=0)||(v2>G->vexnum));
     printf(" The arc  weight:");scanf("%d",&w);
     i = LocateVex(*G,v1); j = LocateVex(*G,v2);
     (G->arcs)[i][j].adj = w;
     if(IncInfo){
       printf(" Enter %d arc's IncInfo:",k+1);
       scanf("%s",(G->arcs)[i][j].info ); fflush(stdin);
     }
     printf("/n");
   }
   return OK;
}

int CreateUDG( AMGraph *G )
{
   int IncInfo,i,j,k;    VertexType v1,v2;
   printf("/n/n The Graph's number of Vertex :"); scanf("%d",&(G->vexnum));
   printf(" The Graph's number of Arcnum :"); scanf("%d",&(G->arcnum));
   printf(" The Graph's incinfo:"); scanf("%d", &IncInfo);  printf("/n");
   /*顶点编号或者名称*/
   for(i = 0;i < G -> vexnum ;i ++){ printf(" The Graph's %d Vertex's NAME:",i+1); scanf("%d",(G->vexs)+i); }
   /*初始化邻接矩阵*/
   for(i=0;i< G->vexnum ;i++)
     for(j=0;j< G->vexnum ;j++){ (G->arcs)[i][j].adj = UNADJACENCY; (G->arcs)[i][j].info = NULL ; }
   /* 构造邻接矩阵 */
   for(k = 0;k < G -> arcnum;k ++){
     printf("/n The %d Arc ./n",k+1);
     printf(" The tail vertex:");do{ scanf("%d",&v1);if((v1<=0)||(v1>G->vexnum))printf(" ERROR/n The tail vertex:"); }while((v1<=0)||(v1>G->vexnum));
     printf(" The head vertex:");do{ scanf("%d",&v2);if((v2<=0)||(v2>G->vexnum))printf(" ERROR/n The head vertex:"); }while((v2<=0)||(v2>G->vexnum));
     i = LocateVex(*G,v1); j = LocateVex(*G,v2);
     (G->arcs)[i][j].adj = ADJACENCY;
     if(IncInfo){
       printf(" Enter %d arc's IncInfo:",k+1);
       scanf("%s",(G->arcs)[i][j].info ); fflush(stdin);
     }
     (G->arcs)[j][i] = (G->arcs)[i][j];
     printf("/n");
   }
   return OK;
}
int CreateUDN( AMGraph *G )
{
   int IncInfo,i,j,k;
   VertexType v1,v2,w;

   printf("/n/n The Graph's number of Vertex :"); scanf("%d",&(G->vexnum));
   printf(" The Graph's number of Arcnum :"); scanf("%d",&(G->arcnum));
   printf(" The Graph's incinfo:"); scanf("%d", &IncInfo);  printf("/n");

   /*顶点编号或者名称*/
   for(i = 0;i < G -> vexnum ;i ++){
     printf(" The Graph's %d Vertex's NAME:",i+1); scanf("%d",(G->vexs)+i);
   }
   /*初始化邻接矩阵*/
   for(i=0;i< G->vexnum ;i++)
     for(j=0;j< G->vexnum ;j++){
      (G->arcs)[i][j].adj = NETWORK_INFINITY; (G->arcs)[i][j].info = NULL ;
     }
   /* 构造邻接矩阵 */
   for(k = 0;k < G -> arcnum;k ++){
     printf("/n The %d Arc ./n",k+1);
     printf(" The tail vertex:");do{ scanf("%d",&v1);if((v1<=0)||(v1>G->vexnum))printf(" ERROR/n The tail vertex:"); }while((v1<=0)||(v1>G->vexnum));
     printf(" The head vertex:");do{ scanf("%d",&v2);if((v2<=0)||(v2>G->vexnum))printf(" ERROR/n The head vertex:"); }while((v2<=0)||(v2>G->vexnum));
     printf(" The arc  weight:");scanf("%d",&w);
     i = LocateVex(*G,v1); j = LocateVex(*G,v2);
     (G->arcs)[i][j].adj = w;
     if(IncInfo){
       printf(" Enter %d arc's IncInfo:",k+1);
       scanf("%s",(G->arcs)[i][j].info ); fflush(stdin);
     }
     (G->arcs)[j][i] = (G->arcs)[i][j];
     printf("/n");
   }
   return OK;
}

/*----------------------------3、 LocateVex(G,u)------------------------------*/
int LocateVex( AMGraph G,VertexType u )
{
   int ivex;
   for(ivex = 0;ivex < G.vexnum ;ivex ++)
     if(u == G.vexs[ivex])
       return ivex;
   return ERROR;
}

/*------------------------6、 FirstAdjVex(G,v)----------------------------*/
/*操作结果: 返回v的第一个邻接顶点。若顶点在G中没有邻接顶点，则返回“空”。*/
int FirstAdjVex(AMGraph G,int ivex)
{
   int jvex;
   for(jvex =0;jvex < G.vexnum;jvex ++)
     if(G.arcs[ivex][jvex].adj == ADJACENCY)  return jvex;
   if(jvex >= G.vexnum)  return ERROR;
}

/*-------------------------7、 NextAdjVex(G,v,w)----------------------------*/
/*操作结果:返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接顶点，则返回“空”。 */

int NextAdjVex(AMGraph G,int ivex ,int jw)
{
   for(jw +=1 ;jw < G.vexnum;jw ++)
     if(G.arcs[ivex][jw].adj == ADJACENCY) return jw;
   if(jw >= G.vexnum)   return  ERROR;
}
/*--------------------------11、深度优先遍历---------------------------------*/
/* int visited[MAX_VERTEX_NUM] */
void VisitFunc(AMGraph G,int v)
{
  printf("%6d",G.vexs[v]);
}

void DFS( AMGraph G,int v )
{
   int w;
   visited[v] = TRUE; VisitFunc(G,v);
   for(w = FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))
     if(!visited[w])  DFS(G,w);
}

void DFSTraverse( AMGraph G,int v )
{
   for(v=0;v<G.vexnum;v++) visited[v] = FALSE;
   for(v=0;v<G.vexnum;v++)
     if(!visited[v]) DFS(G,v);
}


/*-------------------------- 12、广度优先遍历----------------------------------*/
void BFSTraverse(AMGraph G)
{
  int v,u,w; QUEUE Q;elemtype e1,e2,e3;

  for(v=0;v<G.vexnum;v++)  visited[v] = FALSE;
  queue_init(&Q);

  for(v = 0;v<G.vexnum;v++)
    if(!visited[v])
    {
      visited[v]=TRUE; VisitFunc(G,v);
      e1.data = v;
      queue_push(&Q,e1);

      while(!queue_empty(&Q))
      {
        queue_pop(&Q,&e2); u = e2.data;
        for(w = FirstAdjVex(G,u);w >= 0;w=NextAdjVex(G,u,w))
         if(!visited[w])
         {
            visited[w]=TRUE;VisitFunc(G,w);
            e3.data =w;queue_push(&Q,e3);
          }/* if */
      }/* while */
  }/* if */
}

 

/*============================================================================*/

/*============================主函数main()====================================*/
int main( void )
{
   int i,j,ivex;
   AMGraph G;
   CreateGraph( &G );

   printf("The Adjacency Matrix is:/n");
   for(i = 0;i < G.vexnum;i ++){
     for(j = 0;j < G.vexnum;j ++)
       printf("%6d",G.arcs[i][j].adj);
     printf("/n");
   }

   printf("/nDFSTraverse AMGraph:/n");
   DFSTraverse(G,ivex);
   printf("/nBFSTraverse AMGraph:/n");
   BFSTraverse(G);
   getch();

}

YHS_CODE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度优先遍历和广度优先遍历
知世同学的小书房
12-19 406
一.深度优先遍历(DFS) 首先创建一个visited[]数组用来标记是否被访问过，未被访问过赋值为0 将图、一个顶点和visited[]数组传入函数，进行递归遍历 void DFS(Graph*g,int v,bool visited[])//v为点v的位置 { print("%c-->",getv(v));//从v的位置得到v，并将其输出 visited[v]=1;//表示已经被访问过了 int w=getfirstneighbor(g,getv(v));//得到第一个
广度优先遍历和深度优先遍历html文件.zip
05-22
在JavaScript编程中，广度优先遍历（Breadth-First Search, BFS）和深度优先遍历（Depth-First Search, DFS）是两种常见的树或图的遍历算法。这两种算法在处理数据结构时有着广泛的应用，特别是在网络爬虫、图形用户...
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS）
热门推荐
qq_44918331的博客
04-09 2万+
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS） 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 前言 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻
广度优先遍历
weixin_30565199的博客
07-05 1174
--------------------siwuxie095 广度优先遍历 广度优先遍历，也被称为 层序优先遍历，从遍历的起始点 开始，一层一层地向下推 看如下实例： 这张图的邻接表如下： 对于广度优先遍历，...
深度优先遍历及广度优先遍历
青梅煮酒论英雄的博客
11-17 387
深度优先遍历 Depth-First-Search（DFS） 自上而下的遍历搜索 (时间比广度要长，但是空间更少) 堆栈的形式, 即先进后出 广度优先遍历 Breadth-First-Search （BFS） 广度优先逐层遍历 （时间比深度要短，但是花费的空间更大） 队列的形式, 即先进先出 两者差别 深度优先不需要记住所有的节点, 所以占用空间小, 而广度优先需要先记录所有的节点占用空间大 深度优先有回溯的操作(没有路走了需要回头)所以相对而言时间会长一点 代码实现 const data = [
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
本文详细介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，通过实例代码展示了深度优先遍历和广度优先遍历的实现过程，并对二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧进行了详细...
图的广度优先遍历和深度优先遍历实用.pdf
11-08
图的遍历是图论中的基础操作，主要分为两种方法：广度优先遍历（Breadth First Search, BFS）和深度优先遍历（Depth First Search, DFS）。这两种方法广泛应用于算法设计，如搜索问题、最短路径计算、拓扑排序等。 ...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
JavaScript中的深度优先遍历(DFS)和广度优先遍历(BFS)
01-08
在JavaScript中，深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search）是两种常见的图或树的遍历算法，广泛应用于数据结构和算法中，例如在游戏编程、图论问题解决、网页爬虫等领域...
图的深度、广度优先遍历（c语言）.rar
05-07
在这个压缩包中，包含了一个用C语言实现的程序，用于执行图的深度优先遍历（DFS, Depth-First Search）和广度优先遍历（BFS, Breadth-First Search）。以下是这两个遍历方法的详细解释： 1. **深度优先遍历（DFS）*...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
PHP实现二叉树的深度优先与广度优先遍历方法
12-19
二叉树遍历是访问二叉树中所有节点的一种方法，主要分为两种策略：深度优先遍历（DFS）和广度优先遍历（BFS）。这两种遍历方式在PHP中可以通过数据结构和算法实现。 **一、广度优先遍历（BFS）** 广度优先遍历的...
js实现深度优先遍历和广度优先遍历
weixin_33692284的博客
01-25 502
深度优先遍历和广度优先遍历 什么是深度优先和广度优先 其实简单来说 深度优先就是自上而下的遍历搜索 广度优先则是逐层遍历, 如下图所示 1.深度优先 2.广度优先 两者的区别 对于算法来说 无非就是时间换空间 空间换时间 深度优先不需要记住所有的节点, 所以占用空间小, 而广度优先需要先记录所有的节点占用空间大 深度优先有回溯的操作(没有路走了需要回头)所以相对而言时间会长一点 深度优先采用的...
深度优先和广度优先遍历区别。
qq_33233239的博客
05-25 1393
https://www.cnblogs.com/attitudeY/p/6790219.html
广度优先遍历和深度优先遍历区别
最新发布
11-02
广度优先遍历和深度优先遍历都是图的遍历算法，但它们的遍历方式不同。广度优先遍历是从起点开始，依次遍历与起点相邻的所有节点，然后再遍历与这些节点相邻的所有节点，以此类推，直到遍历完整张图。而深度优先遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值