图的广度、深度优先遍历 C语言

  以下是老师作为数据结构课的作业的要求,没有什么实际用处和可以探讨和总结的的地方,所以简单代码直接展示。

宽度优先遍历:

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5
 6 #define _clr(x, y) memset(x, y, sizeof(x))
 7 #define N 1010
 8
 9 int head[N], tot;
10 struct Edge
11 {
12     int v, next;
13 }edge[N];
14 int Queue[N];
15 bool used[N];
16
17 void Add(int u, int v)
18 {
19     edge[tot].v = v;
20     edge[tot].next = head[u];
21     head[u] = tot++;
22 }
23
24 void bfs(int s)
25 {
26     _clr(Queue, 0);
27     _clr(used, 0);
28     int front=0, rear=0;
29     Queue[rear++] = 1;
30     cout << s <<" ";
31     used[s] = true;
32     while(front < rear)
33     {
34         int Cur = Queue[front++];
35         for(int i=head[Cur]; i!=-1; i=edge[i].next)
36         {
37             int v = edge[i].v;
38             if(!used[v])
39             {
40                 used[v] = true;
41                 cout << v << " ";
42                 Queue[rear++] = v;
43             }
44         }
45     }
46     cout << endl;
47 }
48 int main()
49 {
50     int n, m, x, y;
51     cout << "请输入图的顶点数和边数: ";
52     while(cin >> n >> m && n+m)
53     {
54         tot = 0;
55         _clr(head, -1);
56         for(int i=0; i<m; i++)
57         {
58             scanf("%d%d",&x, &y);
59             Add(x, y);
60         }
61         cout << "广度优先遍历顺序如下:\n";
62         bfs(1);
63         cout<<endl;
64         cout << "请输入图的顶点数和边数(输入两个0代表结束输入): ";
65     }
66     return 0;
67 }

深度优先遍历:

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5
 6 #define _clr(x, y) memset(x, y, sizeof(x))
 7 #define N 1010
 8
 9 int head[N], tot;
10 struct Edge
11 {
12     int v, next;
13 }edge[N];
14 int Queue[N];
15 bool used[N];
16
17 void Add(int u, int v)
18 {
19     edge[tot].v = v;
20     edge[tot].next = head[u];
21     head[u] = tot++;
22 }
23
24 void dfs(int s)
25 {
26     cout << s << " ";
27     for(int i=head[s]; i!=-1; i=edge[i].next)
28     {
29         int v = edge[i].v;
30         if(!used[v])
31         {
32             used[v] = true;
33             dfs(v);
34         }
35     }
36 }
37 int main()
38 {
39     int n, m, x, y;
40     cout << "请输入图的顶点数和边数: ";
41     while(cin >> n >> m && n+m)
42     {
43         tot = 0;
44         _clr(head, -1);
45         for(int i=0; i<m; i++)
46         {
47             scanf("%d%d",&x, &y);
48             Add(x, y);
49         }
50         cout << "深优先遍历顺序如下:\n";
51         dfs(1);
52         cout<<endl;
53         cout << "请输入图的顶点数和边数(输入两个0代表结束输入): ";
54     }
55     return 0;
56 }
时间: 2024-11-01 18:33:39

图的广度、深度优先遍历 C语言的相关文章

无向图 深度优先遍历 c语言实现

无向图的深度优先遍历的实现,无向图用邻接表表示无向图的表示:邻接矩阵和邻接表. 程序使用的示例图为: 实现要点: 每个节点有三种状态-1,0,1,分别表示未发现,已经发现,已经处理. 代码如下: #include <stdio.h> #include <stdlib.h> #include "graph_represent.h" //后序遍历图 void DFS(struct vNode** adj,int v,int* color){ struct vNode

数据结构算法之图的存储与遍历(Java)

一:图的分类 1:无向图 即两个顶点之间没有明确的指向关系,只有一条边相连,例如,A顶点和B顶点之间可以表示为 <A, B> 也可以表示为<B, A>,如下所示 2:有向图 顶点之间是有方向性的,例如A和B顶点之间,A指向了B,B也指向了A,两者是不同的,如果给边赋予权重,那么这种异同便更加显著了 =============================================================================================

各种图的创建以及广度,深度优先遍历(临接矩阵存储)

#include <stdio.h> #include <iostream> #include <limits.h> #include <queue> #define INFINTY INT_MAX //最大值 #define MaxVertexNum 100 //最大顶点数 using namespace std; typedef enum{DG,UDG,DN,UDN} GraphKind; //图的种类(有向图.无向图,又向网,无向网) typedef

java实现图的遍历(深度优先遍历和广度优先遍历)

package arithmetic.graphTraveral;import java.util.LinkedList;import java.util.Queue; /** * 这个例子是图的遍历的两种方式 * 通过它,使我来理解图的遍历 * Created on 2013-11-18 * @version 0.1 */public class GraphTraveral{ // 邻接矩阵存储图 // --A B C D E F G H I // A 0 1 0 0 0 1 1 0 0 //

图的广度遍历和深度遍历

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

C++实现图的邻接矩阵的创建以及其深度优先遍历和广度优先遍历

#include<iostream> using namespace std; typedef char vertextype; typedef int edgetype; #define maxvex 100 #define infinity 1000 #include<queue> int visited[100]; class MGraph{ public: vertextype vexs[maxvex]; edgetype arc[maxvex][maxvex]; int

8649 图的广度遍历

8649 图的广度遍历 时间限制:1000MS  内存限制:1000K提交次数:1573 通过次数:975 题型: 编程题   语言: G++;GCC Description 使用图的深度遍历实现的邻接表存储结构和基本操作函数,在此基础上实现图的广度遍历算法并加以测试.注意正确使用队列存储结构. 输入格式 第一行:输入0到3之间整数(有向图:0,有向网:1,无向图:2,无向网:3): 第二行:输入顶点数和边数: 第三行:输入各个顶点的值(字符型,长度〈3):(遍历从输入的第一个顶点开始) 第四行

基于邻接表存储的图的深度优先遍历和广度优先遍历

一.深度优先遍历是连通图的一种遍历策略.其基本思想如下: 设x是当前被访问顶点,在对x做过访问标记后,选择一条从x出发的未检测过的边(x,y).若发现顶点y已访问过,则重新选择另一条从x出发的未检测过的边,否则沿边(x,y)到达未曾访问过的y,对y访问并将其标记为已访问过:然后从y开始搜索,直到搜索完从y出发的所有路径,即访问完所有从y出发可达的顶点之后,才回溯到顶点x,并且再选择一条从x出发的未检测过的边.上述过程直至从x出发的所有边都已检测过为止. 例如下图中: 1.从0开始,首先找到0的关

图的深度优先遍历&amp;广度优先遍历

1.什么是图的搜索? 指从一个指定顶点可以到达哪些顶点 2.图的两种存储结构 (1)邻接矩阵 原理就是用两个数组,一个一维数组保存顶点集,一个二维数组(邻接矩阵)保存边集. (2)邻接表 2.深度优先遍历