图深度优先搜索广度优先搜索,邻接表

2024-08-27 06:32

本文主要是介绍图深度优先搜索广度优先搜索,邻接表,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

#include <stdafx.h>#include"iostream"#include"malloc.h"using namespace std;#define MaxVertexNum 50        //定义最大顶点数typedef struct node{       //边表结点char adjvex;          //邻接点域struct node *next;    //链域}EdgeNode;typedef struct vnode{     //顶点表结点char vertex;           //顶点域EdgeNode *firstedge; //边表头指针}VertexNode;typedef VertexNode AdjList[MaxVertexNum];       //AdjList是邻接表类型typedef struct {AdjList adjlist;     //邻接表int n,e;             //图中当前顶点数和边数} ALGraph;               //图类型//           建立图的邻接表          void CreatALGraph(ALGraph *G){int i,j,k;char a;EdgeNode *s;        //定义边表结点cout<<"请输入顶点数和边数: ";cin>>i;cin>>j;     //读入顶点数和边数G->n=i;G->e=j;cout<<"请输入顶点编号:";for(i=0;i<G->n;i++)     //建立边表{cin>>a;G->adjlist[i].vertex=a;      //读入顶点信息G->adjlist[i].firstedge=NULL; //边表置为空表}cout<<"请输入由两个顶点构成的边,示例:0 1"<<endl;for(k=0;k<G->e;k++){ //建立边表cin>>i;cin>>j;        //读入边(Vi,Vj)的顶点对序号s=(EdgeNode *)malloc(sizeof(EdgeNode));    //生成边表结点s->adjvex=j;                 //邻接点序号为js->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=s;     //将新结点*S插入顶点Vi的边表头部s=(EdgeNode *)malloc(sizeof(EdgeNode));s->adjvex=i;                  //邻接点序号为is->next=G->adjlist[j].firstedge;  G->adjlist[j].firstedge=s;      //将新结点*S插入顶点Vj的边表头部}}//定义标志向量为全局变量        typedef enum{FALSE,TRUE} Boolean;Boolean visited[MaxVertexNum];// DFS:深度优先遍历的递归算法      void DFSM(ALGraph *G,int i){                        //以Vi为出发点对邻接链表表示的图G进行DFS搜索EdgeNode *p;cout<<G->adjlist[i].vertex;   //访问顶点Vivisited[i]=TRUE;                    //标记Vi已访问p=G->adjlist[i].firstedge;           //取Vi边表的头指针while(p) {                 //依次搜索Vi的邻接点Vj,这里j=p->adjvexif(! visited[p->adjvex])      //若Vj尚未被访问DFSM(G,p->adjvex);       //则以Vj为出发点向纵深搜索p=p->next;                    //找Vi的下一个邻接点}}void DFS(ALGraph *G){for(int i=0;i<G->n;i++)visited[0]=FALSE;        //标志向量初始化for(int i=0;i<G->n;i++)if(!visited[0])              //Vi未访问过DFSM(G,0);                //以Vi为源点开始DFS搜索}//广度优先遍历       void BFS(ALGraph *G){  int k=0;                       /*以Vk为源点对用邻接链表表示的图G进行广度优先搜索*/int i,f=0,r=0;EdgeNode *p;int cq[MaxVertexNum];         //定义FIFO队列for(i=0;i<G->n;i++)visited[i]=FALSE;             //标志向量初始化for(i=0;i<=G->n;i++)cq[i]=-1;                          //初始化标志向量cout<<G->adjlist[k].vertex; //访问源点Vkvisited[k]=TRUE;cq[r]=k;           //Vk已访问,将其入队。注意,实际上是将其序号入队while(cq[f]!=-1) {   //队列非空则执行i=cq[f]; f=f+1;                //Vi出队p=G->adjlist[i].firstedge;     //取Vi的边表头指针while(p) {                //依次搜索Vi的邻接点Vj(令p->adjvex=j)if(!visited[p->adjvex]) {           //若Vj未访问过cout<<G->adjlist[p->adjvex].vertex;      //访问Vjvisited[p->adjvex]=TRUE;r=r+1; cq[r]=p->adjvex;           //访问过的Vj入队}p=p->next;               //找Vi的下一个邻接点}}                              }      int main(){int i,x;ALGraph *G;G=(ALGraph *)malloc(sizeof(ALGraph));CreatALGraph(G);cout<<"遍历结果与构造边的顺序有关。"<<endl;cout<<"深度优先 "<<endl;DFS(G);cout<<endl;cout<<"广度优先"<<endl;BFS(G);cout<<endl;}

图的遍历(Traversing Graph)是指从图中某一顶点出发访问图中其余顶点,且使每个顶点仅被访问一次。

广度优先搜索(Breadth First Search)

       广度优先搜索假设从图中某个顶点v出发,在访问了v之后依次访问v的各个未曾访问过的邻接点,然后再分别从这些邻接点出发依次访问它们的邻接点,并使先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问(因此需要用队列来存储顶点),直到图中所有已被访问的顶点的邻接点都被访问为止。如果此时图中还有未被访问的顶点,则另选图中未被访问的顶点作为起点,重复上述过程,直到图中所有顶点都被访问为止。

采用邻接表存储图的具体实现如下:

[cpp] view plain copy print ?
  1. #include <iostream>  
  2. #include <queue>  
  3. #include <cstdio>  
  4. #include <cstdlib>  
  5. using namespace std;  
  6.   
  7. #define VERTEXNUM 100 //顶点个数  
  8. typedef char VertexType;  
  9. typedef int EdgeType;  
  10. typedef enum{FALSE, TRUE} Boolean;  
  11. Boolean visited[VERTEXNUM];  
  12.   
  13. /*************************************** 
  14.  * 
  15.  * 邻接表存储结构  
  16.  * 
  17.  * *************************************/  
  18. typedef struct node  
  19. {  
  20.     int adjvex; //顶点位置  
  21.     struct node *next; //指向下一条边的指针  
  22. }EdgeNode;  
  23.   
  24. typedef struct vnode  
  25. {  
  26.     VertexType vertex; //顶点信息  
  27.     EdgeNode *firstedge; //指向第一条依附该顶点的边的指针  
  28. }AdjList[VERTEXNUM];  
  29.   
  30. typedef struct  
  31. {  
  32.     AdjList vertexs; //邻接表  
  33.     int vernum, edgenum; //图中当前的顶点和边数  
  34. }Graph;  
  35.   
  36. /*************************************** 
  37.  * 
  38.  * 建立图的邻接表 
  39.  * 
  40.  * *************************************/  
  41. void MakeGraph(Graph *graph)  
  42. {  
  43.   
  44.     int v1, v2;  
  45.     int i, j, k;  
  46.     printf("请输入图的顶点数n和边数e:\n");  
  47.     scanf("%d%d", &graph->vernum, &graph->edgenum);  
  48.     printf("请输入顶点信息(顶点号<CR>)每个顶点以回车作为结束:\n");  
  49.   
  50.     for(i = 0; i < graph->vernum; i++)  
  51.     {  
  52.         getchar();  
  53.         scanf("%c", &graph->vertexs[i].vertex);  
  54.         graph->vertexs[i].firstedge = NULL; //初始第一条边为空  
  55.     }  
  56.   
  57.     printf("请输入每条边对应的两个顶点的序号(格式为i,j):\n");  
  58.     EdgeNode *p;  
  59.     for(k = 0; k < graph->edgenum; k++)  
  60.     {  
  61.         scanf("%d,%d", &i, &j);  //读入边<vi,vj>的序号  
  62.         p = (node *)malloc(sizeof(node)); //生成新的结点  
  63.         p->adjvex = j - 1;  
  64.         p->next = graph->vertexs[i - 1].firstedge;  
  65.         graph->vertexs[i - 1].firstedge = p;  
  66.     }  
  67. }  
  68.   
  69. /*************************************** 
  70.  * 
  71.  * 广度优先遍历 
  72.  * 
  73.  * *************************************/  
  74. void BFS(Graph *graph)  
  75. {  
  76.     int i, j, k;  
  77.     queue<int> q;  
  78.     EdgeNode *p;  
  79.     for(i = 0; i < graph->vernum; i++) //初始化访问标识数组  
  80.         visited[i] = FALSE;  
  81.   
  82.     for(i = 0; i < graph->vernum; i++)  
  83.     {  
  84.         if(!visited[i])  
  85.         {  
  86.             visited[i] = TRUE;  
  87.             printf("广度优先遍历:结点%c\n", graph->vertexs[i].vertex);  
  88.             q.push(i); //入栈  
  89.             while(!q.empty())  
  90.             {  
  91.                 j = q.front();   
  92.                 q.pop();  //出栈  
  93.                 p = graph->vertexs[j].firstedge;  
  94.                 while(p)  
  95.                 {  
  96.                     if(!visited[p->adjvex])  
  97.                     {  
  98.                         printf("广度优先遍历:结点%c\n", graph->vertexs[p->adjvex].vertex);  
  99.                         visited[p->adjvex] = TRUE;  
  100.                         q.push(p->adjvex);  
  101.                     }  
  102.                     p = p->next;  
  103.                 }  
  104.             }  
  105.         }  
  106.     }  
  107. }  
  108.   
  109. int main()  
  110. {  
  111.     Graph *graph = (Graph *)malloc(sizeof(Graph));  
  112.     MakeGraph(graph); //建立图的邻接表  
  113.     BFS(graph); //广度优先遍历  
  114.   
  115.     return 0;  
  116. }  

图一中的图,运行上述程序得到的结果如图二。

图一


图二




这篇关于图深度优先搜索广度优先搜索,邻接表的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1110895

相关文章

SpringCloud动态配置注解@RefreshScope与@Component的深度解析

《SpringCloud动态配置注解@RefreshScope与@Component的深度解析》在现代微服务架构中,动态配置管理是一个关键需求,本文将为大家介绍SpringCloud中相关的注解@Re... 目录引言1. @RefreshScope 的作用与原理1.1 什么是 @RefreshScope1.

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步:深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步

Redis中高并发读写性能的深度解析与优化

《Redis中高并发读写性能的深度解析与优化》Redis作为一款高性能的内存数据库,广泛应用于缓存、消息队列、实时统计等场景,本文将深入探讨Redis的读写并发能力,感兴趣的小伙伴可以了解下... 目录引言一、Redis 并发能力概述1.1 Redis 的读写性能1.2 影响 Redis 并发能力的因素二、

最新Spring Security实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)

《最新SpringSecurity实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)》本章节介绍了如何通过SpringSecurity实现从配置自定义登录页面、表单登录处理逻辑的配置,并简单模拟... 目录前言改造准备开始登录页改造自定义用户名密码登陆成功失败跳转问题自定义登出前后端分离适配方案结语前言

Python使用DeepSeek进行联网搜索功能详解

《Python使用DeepSeek进行联网搜索功能详解》Python作为一种非常流行的编程语言,结合DeepSeek这一高性能的深度学习工具包,可以方便地处理各种深度学习任务,本文将介绍一下如何使用P... 目录一、环境准备与依赖安装二、DeepSeek简介三、联网搜索与数据集准备四、实践示例:图像分类1.

Redis 内存淘汰策略深度解析(最新推荐)

《Redis内存淘汰策略深度解析(最新推荐)》本文详细探讨了Redis的内存淘汰策略、实现原理、适用场景及最佳实践,介绍了八种内存淘汰策略,包括noeviction、LRU、LFU、TTL、Rand... 目录一、 内存淘汰策略概述二、内存淘汰策略详解2.1 ​noeviction(不淘汰)​2.2 ​LR

Python与DeepSeek的深度融合实战

《Python与DeepSeek的深度融合实战》Python作为最受欢迎的编程语言之一,以其简洁易读的语法、丰富的库和广泛的应用场景,成为了无数开发者的首选,而DeepSeek,作为人工智能领域的新星... 目录一、python与DeepSeek的结合优势二、模型训练1. 数据准备2. 模型架构与参数设置3

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列(LCS)问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动

Go中sync.Once源码的深度讲解

《Go中sync.Once源码的深度讲解》sync.Once是Go语言标准库中的一个同步原语,用于确保某个操作只执行一次,本文将从源码出发为大家详细介绍一下sync.Once的具体使用,x希望对大家有... 目录概念简单示例源码解读总结概念sync.Once是Go语言标准库中的一个同步原语,用于确保某个操