爪哇2博客
爪哇2博客

爪哇中的广度优先搜索

如果您想练习数据结构和算法程序,可以通过 数据结构和算法面试题.

我们已经在中看到有关广度优先搜索的信息 二叉树的层级遍历.

图遍历算法:

广度优先搜索是图遍历算法。在此算法中,假设我们从节点i开始,然后我们将访问i的邻居,然后访问i的邻居的邻居,依此类推。

它与二叉树中使用的非常相似。我们使用队列遍历图。我们将第一个节点放入队列。它反复提取节点并将其邻居放入队列。关于二叉树的唯一区别是,我们需要跟踪是否以前访问过节点。借助于节点中访问的布尔变量可以很容易地做到这一点。如果节点已经被访问过,那么我们赢了’t visit it again.

算法:

广度优先搜索的步骤:

  1. 创建空队列并将根节点推送到该队列。
  2. 当队列不为空时,请执行以下操作
    • 从队列中弹出一个节点并进行打印。
    • 借助邻接矩阵查找节点的邻居,并检查节点是否已被访问。
    • 如果不为null,则将节点的邻居推入队列

让我们借助示例来理解:
可以说图是:

图形
广度优先搜索遍历

爪哇 BFS示例

有两种表示图形的方法。

  • 使用邻居列表
  • 使用邻接矩阵

使用邻居列表

在此,您可以拥有列表<Node> as 邻居 in 节点 类 as below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
组织.Arpit.爪哇2blog.图形;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.链表;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序.队列;
 
上市 广度优先搜索示例邻居列表
{
 
私人的 队列<节点> 队列;
静态的 数组列表<节点> 节点= 数组列表<节点>();
静态的 节点
{
整型 数据;
布尔值 参观过;
清单<节点> 邻居;
 
节点(整型 数据)
{
这个.数据=数据;
这个.邻居= 数组列表<>();
 
}
上市 虚空 邻居(节点 邻居节点)
{
这个.邻居.(邻居节点);
}
上市 清单<节点> 得到Neighbours() {
返回 邻居;
}
上市 虚空 setNeighbours(清单<节点> 邻居) {
这个.邻居 = 邻居;
}
}
 
上市 广度优先搜索示例邻居列表()
{
队列 = 链表<节点>();
}
 
上市 虚空 bfs(节点 节点)
{
队列.(节点);
节点.参观过=真正;
(!队列.是空的())
{
 
节点 元件=队列.去掉();
系统..打印(元件.数据 + “ t”);
清单<节点> 邻居=元件.得到Neighbours();
对于 (整型 i = 0; i < 邻居.尺寸(); i++) {
节点 n=邻居.得到(i);
如果(n!=空值 && !n.参观过)
{
队列.(n);
n.参观过=真正;
 
}
}
 
}
}
 
上市 静态的 虚空 主要( 精氨酸[])
{
 
节点 节点40 = 节点(40);
节点 节点10 = 节点(10);
节点 节点20 = 节点(20);
节点 节点30 = 节点(30);
节点 节点60 = 节点(60);
节点 节点50 = 节点(50);
节点 节点70 = 节点(70);
 
节点40.邻居(节点10);
节点40.邻居(节点20);
节点10.邻居(节点30);
节点20.邻居(节点10);
节点20.邻居(节点30);
节点20.邻居(节点60);
节点20.邻居(节点50);
节点30.邻居(节点60);
节点60.邻居(节点70);
节点50.邻居(节点70);
系统..打印(“图表的BFS遍历为”);
广度优先搜索示例邻居列表 bfsExample = 广度优先搜索示例邻居列表();
bfsExample.bfs(节点40);
 
}
}
 

当您运行上述程序时,将获得以下输出:

该图的BFS遍历为
40 10 20 30 60 50 70

使用邻接矩阵

Adjacency_matrix用于查找两个节点之间的连接。

如果adjacency_matrix [i] [j] == 1,则索引i和索引j的节点已连接

下图将帮助您了解邻接矩阵。

邻接矩阵
创建广度优先搜索示例.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
组织.Arpit.爪哇2blog.图形;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.链表;
进口 爪哇.实用程序.队列;
 
上市 广度优先搜索示例
{
 
私人的 队列<节点> 队列;
静态的 数组列表<节点> 节点= 数组列表<节点>();
静态的 节点
{
整型 数据;
布尔值 参观过;
 
节点(整型 数据)
{
这个.数据=数据;
 
}
}
 
上市 广度优先搜索示例()
{
队列 = 链表<节点>();
}
 
//使用邻接矩阵找到节点的邻居
//如果adjacency_matrix [i] [j] == 1,则索引i和索引j的节点已连接
上市 数组列表<节点> findNeighbours(整型 adjacency_matrix[][],节点 x)
{
整型 节点Index=-1;
 
数组列表<节点> 邻居= 数组列表<节点>();
对于 (整型 i = 0; i < 节点.尺寸(); i++) {
如果(节点.得到(i).等于(x))
{
节点Index=i;
打破;
}
}
 
如果(节点Index!=-1)
{
对于 (整型 j = 0; j < adjacency_matrix[节点Index].长度; j++) {
如果(adjacency_matrix[节点Index][j]==1)
{
邻居.(节点.得到(j));
}
}
}
返回 邻居;
}
 
上市 虚空 bfs(整型 adjacency_matrix[][], 节点 节点)
{
队列.(节点);
节点.参观过=真正;
(!队列.是空的())
{
 
节点 元件=队列.去掉();
系统..打印(元件.数据 + “ t”);
数组列表<节点> 邻居=findNeighbours(adjacency_matrix,元件);
对于 (整型 i = 0; i < 邻居.尺寸(); i++) {
节点 n=邻居.得到(i);
如果(n!=空值 && !n.参观过)
{
队列.(n);
n.参观过=真正;
 
}
}
 
}
}
 
上市 静态的 虚空 主要( 精氨酸[])
{
 
节点 节点40 = 节点(40);
节点 节点10 = 节点(10);
节点 节点20 = 节点(20);
节点 节点30 = 节点(30);
节点 节点60 = 节点(60);
节点 节点50 = 节点(50);
节点 节点70 = 节点(70);
 
节点.(节点40);
节点.(节点10);
节点.(节点20);
节点.(节点30);
节点.(节点60);
节点.(节点50);
节点.(节点70);
整型 adjacency_matrix[][] = {
{0,1,1,0,0,0,0}, // 节点 1: 40
{0,0,0,1,0,0,0}, // 节点 2 :10
{0,1,0,1,1,1,0}, // 节点 3: 20
{0,0,0,0,1,0,0}, // 节点 4: 30
{0,0,0,0,0,0,1}, // 节点 5: 60
{0,0,0,0,0,0,1}, // 节点 6: 50
{0,0,0,0,0,0,0}, // 节点 7: 70
};
系统..打印(“图表的BFS遍历为”);
广度优先搜索示例 bfsExample = 广度优先搜索示例();
bfsExample.bfs(adjacency_matrix, 节点40);
 
}
}
 

当您运行上述程序时,将获得以下输出:

1
2
3
4
 
BFS 遍历 图形
40 10 20 30 60 50 70
 

请通过 爪哇中的算法面试程序  有关更多此类程序。


导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客