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

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

相关文章

认识、理解、分类——acm之搜索

普通搜索方法有两种:1、广度优先搜索;2、深度优先搜索; 更多搜索方法: 3、双向广度优先搜索; 4、启发式搜索(包括A*算法等); 搜索通常会用到的知识点:状态压缩(位压缩,利用hash思想压缩)。

hdu1240、hdu1253(三维搜索题)

1、从后往前输入,(x,y,z); 2、从下往上输入,(y , z, x); 3、从左往右输入,(z,x,y); hdu1240代码如下: #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#inc

hdu1180(广搜+优先队列)

此题要求最少到达目标点T的最短时间,所以我选择了广度优先搜索,并且要用到优先队列。 另外此题注意点较多,比如说可以在某个点停留,我wa了好多两次,就是因为忽略了这一点,然后参考了大神的思想,然后经过反复修改才AC的 这是我的代码 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<

poj 3190 优先队列+贪心

题意: 有n头牛,分别给他们挤奶的时间。 然后每头牛挤奶的时候都要在一个stall里面,并且每个stall每次只能占用一头牛。 问最少需要多少个stall,并输出每头牛所在的stall。 e.g 样例: INPUT: 51 102 43 65 84 7 OUTPUT: 412324 HINT: Explanation of the s

poj 2431 poj 3253 优先队列的运用

poj 2431: 题意: 一条路起点为0, 终点为l。 卡车初始时在0点,并且有p升油,假设油箱无限大。 给n个加油站,每个加油站距离终点 l 距离为 x[i],可以加的油量为fuel[i]。 问最少加几次油可以到达终点,若不能到达,输出-1。 解析: 《挑战程序设计竞赛》: “在卡车开往终点的途中,只有在加油站才可以加油。但是,如果认为“在到达加油站i时,就获得了一

hdu 4517 floyd+记忆化搜索

题意: 有n(100)个景点,m(1000)条路,时间限制为t(300),起点s,终点e。 访问每个景点需要时间cost_i,每个景点的访问价值为value_i。 点与点之间行走需要花费的时间为g[ i ] [ j ] 。注意点间可能有多条边。 走到一个点时可以选择访问或者不访问,并且当前点的访问价值应该严格大于前一个访问的点。 现在求,从起点出发,到达终点,在时间限制内,能得到的最大

基于UE5和ROS2的激光雷达+深度RGBD相机小车的仿真指南(五):Blender锥桶建模

前言 本系列教程旨在使用UE5配置一个具备激光雷达+深度摄像机的仿真小车,并使用通过跨平台的方式进行ROS2和UE5仿真的通讯,达到小车自主导航的目的。本教程默认有ROS2导航及其gazebo仿真相关方面基础,Nav2相关的学习教程可以参考本人的其他博客Nav2代价地图实现和原理–Nav2源码解读之CostMap2D(上)-CSDN博客往期教程: 第一期:基于UE5和ROS2的激光雷达+深度RG

韦季李输入法_输入法和鼠标的深度融合

在数字化输入的新纪元,传统键盘输入方式正悄然进化。以往,面对实体键盘,我们常需目光游离于屏幕与键盘之间,以确认指尖下的精准位置。而屏幕键盘虽直观可见,却常因占据屏幕空间,迫使我们在操作与视野间做出妥协,频繁调整布局以兼顾输入与界面浏览。 幸而,韦季李输入法的横空出世,彻底颠覆了这一现状。它不仅对输入界面进行了革命性的重构,更巧妙地将鼠标这一传统外设融入其中,开创了一种前所未有的交互体验。 想象

AI基础 L9 Local Search II 局部搜索

Local Beam search 对于当前的所有k个状态,生成它们的所有可能后继状态。 检查生成的后继状态中是否有任何状态是解决方案。 如果所有后继状态都不是解决方案,则从所有后继状态中选择k个最佳状态。 当达到预设的迭代次数或满足某个终止条件时,算法停止。 — Choose k successors randomly, biased towards good ones — Close

hdu4277搜索

给你n个有长度的线段,问如果用上所有的线段来拼1个三角形,最多能拼出多少种不同的? import java.io.BufferedInputStream;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;