第五章 图的遍历(深度遍历,广度遍历,城市地图,最少转机)

深度和广度优先搜索:

单词分解:首先是搜索

深度和广度:是针对图的遍历而言的

图:由顶点和边组成

图的遍历:把图中每一个顶点都访问一次

一:

输入:

5 5(顶点数,边数)

1 2

1 3

1 5

2 4

3 5

输出:

1 2 4 3 5

(按时间戳输出)深度遍历

1 2 3 5 4

(按时间戳输出)广度遍历

 1 #include <stdio.h>
 2 int map[10][10], book[10], n, m,sum;
 3 void dfs(int cur)
 4 {
 5     int i;
 6     printf("%d ",cur);
 7     sum++;
 8     if (sum == n)
 9         return;
10     for (i = 1;i <= n;i++)
11     {
12         if (book[i] == 0 && map[i][cur])
13         {
14             book[i] = 1;
15             dfs(i);
16         }
17     }
18     return;
19 }
20 void bfs(int front)
21 {
22     int que[100];
23     int head = 0, tail = 0;
24     int i;
25     que[tail++] = front;
26     book[front] = 1;
27     while (head < tail)
28     {
29         for (i = 1;i <= n;i++)
30         {
31             if (map[que[head]][i] && book[i]==0)
32             {
33                 book[i] = 1;
34                 que[tail++] = i;
35             }
36         }
37         head++;
38     }
39     for (i = 0;i < tail;i++)
40         printf("%d ",que[i]);
41     printf("\n");
42 }
43 int main()
44 {
45     int x, y,i;
46     scanf("%d%d",&n,&m);
47     for (i = 1;i <= m;i++)
48     {
49         scanf("%d%d",&x,&y);
50         map[x][y] = 1;
51         map[y][x] = 1;
52     }
53     /*book[1] = 1;
54     dfs(1);
55     printf("\n");*/
56     bfs(1);
57     return 0;
58 }

二:城市地图

输入(5个顶点,8条边):

5 8

1 2 2

1 5 10

2 3 3

2 5 7

3 1 4

3 4 4

4 5 5

5 3 3

输出:

9

(从城市1到城市5的最短距离)

 1 #include <stdio.h>
 2 int map[10][10], book[10], n;
 3 int min = 99999;
 4 void dfs(int cur,int sum)
 5 {
 6     int i;
 7     if (min < sum)
 8         return;
 9     if (cur == n)
10     {
11         if (min > sum)
12             min = sum;
13         return;
14     }
15     for (i = 1;i <= n;i++)
16     {
17         if (book[i] == 0 && map[i][cur])
18         {
19             book[i] = 1;
20             dfs(i, sum + map[i][cur]);
21             book[i] = 0;
22         }
23     }
24     return;
25 }
26 int main()
27 {
28     int e,i,x,y,t;
29     scanf("%d%d",&n,&e);
30     for (i = 1;i <= n;i++)
31     {
32         scanf("%d%d%d", &x, &y, &t);
33         map[x][y] = t;
34         map[y][x] = t;
35     }
36     book[1] = 1;
37     dfs(1,0);
38     printf("%d\n",min);
39
40     return 0;
41 }

三:最少转机(图的广度优先遍历)

时间: 2024-08-04 04:31:52

第五章 图的遍历(深度遍历,广度遍历,城市地图,最少转机)的相关文章

深度、广度遍历

深度优先搜索算法(Depth First Search),是搜索算法的一种.是沿着树的深度遍历树的节点,尽可能深的搜索树的分支. 当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点.这一过程一直进行到已发现从源节点可达的所有节点为止. 如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止. 如右图所示的二叉树: A 是第一个访问的,然后顺序是 B.D,然后是 E.接着再是 C.F.G. 那么,怎么样才能来保证这个访问的顺序

图的深度和广度遍历(邻接矩阵)

这里我采用邻接矩阵的存储方式对图进行遍历 #include <iostream> #include <queue> #define INFINITY 100 #define MAXNODE 100 #define OK 1 using namespace std; typedef char VertexType; int vis[MAXNODE]; typedef struct { int adj; } ArcType; typedef struct { VertexType ve

第五章&#160;二叉树(e2)中序遍历

原文地址:https://www.cnblogs.com/ZHONGZHENHUA/p/10258541.html

数据结构导论之第五章图

一.图的概念 图的定义 1.图 在树形结构中,结点间具有层次关系,每一层结点只能和上一层中的至多一个结点相关, 但可能和下一层的多个结点相关.而在图结构中,任意两个结点之间都可能相关,即结点之 间的邻接关系可以是任意的图G:是由集合V和E组成,记成G=(V,E): V 是顶点集(非空):E 是边集 (可空);边是顶点的有序对或无序对;(边反映了两顶点之间的关系) 2.有向图 :边是顶点的有序对的图(图中每条边都用箭头指明了方向)一个具有 n 个顶点的有向完全图的弧 数为 n(n-1)3.无向图

队列模拟递归遍历目录(广度遍历)

import os import collections def getALLDir(path): queue = collections.deque()#空的 queue.append(path)#进队 while len(queue) != 0: dirPath = queue.popleft()#数据出队 filesList = os.listdir(dirPath)#找出所有文件 for fileName in filesList:#处理文件 fileAbsPath = os.path.

python 队列模拟递归遍历目录(广度遍历)

import osimport collections def getAllDirQU(path): queue = collections.deque() #进队 queue.append(path) while len(queue) != 0: #出队数据 dirPath = queue.popleft() #找出所有的文件 filesList = os.listdir(dirPath) for fileName in filesList: #绝对路径 fileAbsPath = os.pa

第五章、图的遍历

第一节.深度与广度优先,究竟是指啥?(无向图)p131 DFS遍历图 1 #include <stdio.h> 2 int book[101],sum,n,e[101][101]; 3 4 void dfs(int cur) 5 { 6 int i; 7 printf("%d ",cur); 8 sum++; 9 if(sum==n) return; 10 for(i=1;i<=n;i++) 11 { 12 if(e[cur][i]==1 && boo

浅谈数据结构之图的邻接表深度和广度优先遍历(九)

邻接矩阵是一种不错的图存储结构,但是我们发现,对于边数相对较少的图,这种结构是存在对存储空间的极大浪费的.我们知道,顺序存储结构存在预先分配内存可能造成空间浪费的问题,于是引出了链式存储的结构.同样的,我们也可以考虑对边或弧使用链式存储的方式来避免空间浪费的问题.因此,对于图的存储结构,我们同样引入了一种数组与链表相组合的存储方法,我们一般称之为邻接表. 邻接表的处理方法是这样的:(1).图中顶点用一个一维数组存储,当然,顶点也可以用单链表来存储,不过数组可以较容易的读取顶点的信息,更加方便:另

图的广度遍历和深度遍历

/* 图的遍历方法主要有两种:一种是深度优先遍历,一种是广度优先遍历.图的深度优先遍历类同于树的先根遍历,图的广度遍历类同树的层次遍历 一:连通图的深度优先遍历算法 图的深度优先遍历算法是遍历时深度优先的算法,即在图的所有邻接顶点中,每次都在访问当前顶点后,首先访问当前顶点的第一个邻接顶点. 连通图的深度优先遍历递归算法如下: 1.访问顶点v并标记顶点v已访问. 2.查找顶点v的第一个邻接顶点w. 3.若顶点v的邻接顶点w存在,则继续执行,否则算法结束. 4.若顶点w尚未被访问,则深度优先遍历递