爪哇中的广度优先搜索
如果您想练习数据结构和算法程序，可以通过 数据结构和算法面试题.
我们已经在中看到有关广度优先搜索的信息 二叉树的层级遍历.
它与二叉树中使用的非常相似。我们使用队列遍历图。我们将第一个节点放入队列。它反复提取节点并将其邻居放入队列。关于二叉树的唯一区别是，我们需要跟踪是否以前访问过节点。借助于节点中访问的布尔变量可以很容易地做到这一点。如果节点已经被访问过，那么我们赢了’t visit it again.
算法：
广度优先搜索的步骤：
- 创建空队列并将根节点推送到该队列。
- 当队列不为空时，请执行以下操作
- 从队列中弹出一个节点并进行打印。
- 借助邻接矩阵查找节点的邻居，并检查节点是否已被访问。
- 如果不为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
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 |
请通过 爪哇中的算法面试程序 有关更多此类程序。
导入联系人
