广度优先搜索 java_Java中的图形：广度优先搜索（BFS）
介绍
图形是存储某些类型的数据的便捷方法。该概念是从数学移植而来的，适合于计算机科学的需求。
由于许多事物可以用图形表示，因此图形遍历已成为一项常见的任务，尤其是在数据科学和机器学习中。
广度优先搜索(BFS)会“逐层”访问。这意味着在一个Graph中(如下图所示)，它首先访问起始节点的所有子节点。这些孩子被视为“第二层”。
与深度优先搜索(DFS)不同，BFS不会主动经过一个分支直到到达末端，而是当我们从一个节点开始搜索时，它会先访问该节点的所有未访问邻居，然后再继续访问所有未访问邻居。另一个节点：
实作
我们将使用通过邻接表实现的图，就像用于DFS一样。另外，我们需要visited在visit()和univisit()方法旁边添加属性到我们的Node类中：
public class Node {
int n;
String name;
boolean visited;
Node(int n, String name) {
this.n = n;
this.name = name;
visited = false;
}
void visit() {
visited = true;
}
void unvisit() {
visited = false;
}
}
现在，让我们定义一个Graph：
public class Graph {
// Each node maps to a list of all his neighbors private HashMap> adjacencyMap;
private boolean directed;
public Graph(boolean directed) {
this.directed = directed;
adjacencyMap = new HashMap<>();
}
// ...}
现在，让我们添加方法addEdge()。我们将使用两种方法，辅助方法和实际方法。
在辅助方法中，我们还将检查可能的重复边缘。在A和之间添加边之前B，我们先将其删除，然后再添加。如果存在(我们要添加重复的边)，则将其删除，然后再次添加，只有一个。
但是，如果它不存在，那么删除不存在的边将导致，NullPointerException因此我们引入了列表的临时副本：
public void addEdgeHelper(Node a, Node b) {
LinkedList tmp = adjacencyMap.get(a);
if (tmp != null) {
tmp.remove(b);
}
else tmp = new LinkedList<>();
tmp.add(b);
adjacencyMap.put(a,tmp);
}
public void addEdge(Node source, Node destination) {
// We make sure that every used node shows up in our .keySet()
if (!adjacencyMap.keySet().contains(source))
adjacencyMap.put(source, null);
if (!adjacencyMap.keySet().contains(destination))
adjacencyMap.put(destination, null);
addEdgeHelper(source, destination);
// If a graph is undirected, we want to add an edge from destination to source as well
if (!directed) {
addEdgeHelper(destination, source);
}
}
最后，我们将有printEdges()，hasEdge()和resetNodesVisited()辅助方法，这是非常简单的：
public void printEdges() {
for (Node node : adjacencyMap.keySet()) {
System.out.print("The " + node.name + " has an edge towards: ");
for (Node neighbor : adjacencyMap.get(node)) {
System.out.print(neighbor.name + " ");
}
System.out.println();
}
}
public boolean hasEdge(Node source, Node destination) {
return adjacencyMap.containsKey(source) && adjacencyMap.get(source).contains(destination);
}
public void resetNodesVisited(){
for(Node node : adjacencyMap.keySet()){
node.unvisit();
}
}
让我们在以下无向图上检查BFS算法：
Node 0 has neighbors: 1, 3, 2
Node 1 has neighbors: 0
Node 2 has neighbors: 3, 0
Node 3 has neighbors: 2, 0
我们可以选择任何节点作为起点，所以从1开始。我们重复从队列中添加和删除节点的过程，直到队列为空。
队列是FIFO(先进先出)数据结构。它的工作方式就像现实中的队列一样，因此，按添加顺序逐个处理条目(从队列中删除)。
对于BFS来说，这是一种非常方便的数据结构，因为我们希望按照访问它们的顺序来处理节点，并确保首先处理与起始节点“更近”的节点。
由于将它们添加到队列中，然后再将离起始节点“更远”的任何节点添加到队列中，因此我们知道将首先处理较近的节点。我们从一个仅包含节点1的队列开始
从队列中删除第一个元素，在本例中为1，将其标记为已访问
将所有1的未访问邻居添加到队列(仅0)
订阅我们的新闻
在收件箱中获取临时教程，指南和作业。从来没有垃圾邮件。随时退订。
订阅电子报
订阅从队列中删除第一个元素，在这种情况下为0，将其标记为已访问
将所有0的未访问邻居添加到队列(节点3和2，1已被标记为已访问)
从队列中删除第一个元素，在本例中为3，将其标记为已访问
将所有3个未访问的邻居添加到队列中(不存在)
从队列中删除第一个元素，在本例中为2，将其标记为已访问
将所有2个未访问的邻居添加到队列中(同样，没有一个)
队列现在为空，BFS已完成
我们的节点按1-0-3-2顺序访问。显然，步骤2-3、4-5、6-7和8-9的设置相同，并且步骤10是我们的循环终止条件。这样看来，为我们的breadthFirstSearch(Node node)方法编写代码应该很容易。
QueueJava有几种类型的实现，但是我们将使用aLinkedList代替，因为它提供了所有必需的方法。
我们在类中添加以下方法Graph：
void breadthFirstSearch(Node node) {
// Just so we handle receiving an uninitialized Node, otherwise an
// exception will be thrown when we try to add it to queue
if (node == null)
return;
// Creating the queue, and adding the first node (step 1)
LinkedList queue = new LinkedList<>();
queue.add(node);
while (!queue.isEmpty()) {
Node currentFirst = queue.removeFirst();
// In some cases we might have added a particular node more than once before
// actually visiting that node, so we make sure to check and skip that node if we have
// encountered it before
if (currentFirst.isVisited())
continue;
// Mark the node as visited
currentFirst.visit();
System.out.print(currentFirst.name + " ");
LinkedList allNeighbors = adjacencyMap.get(currentFirst);
// We have to check whether the list of neighbors is null before proceeding, otherwise
// the for-each loop will throw an exception
if (allNeighbors == null)
continue;
for (Node neighbor : allNeighbors) {
// We only add unvisited neighbors
if (!neighbor.isVisited()) {
queue.add(neighbor);
}
}
}
System.out.println();
}
现在，我们在代码中创建示例图，并检查我们的方法是否按预期工作：
public class GraphShow {
public static void main(String[] args) {
Graph graph = new Graph(false);
Node a = new Node(0, "0");
Node b = new Node(1, "1");
Node c = new Node(2, "2");
Node d = new Node(3, "3");
Node e = new Node(4, "4");
graph.addEdge(a,d);
graph.addEdge(a,b);
graph.addEdge(a,c);
graph.addEdge(c,d);
graph.breadthFirstSearch(b);
}
}
输出：
1 0 3 2
如果您阅读了DFS文章，那么您可能还记得我们曾经遇到过这样的情况：在未连接的图中，并非所有节点都将被打印出来，因为该算法将遍历所有可能的节点，然后停止。
BFS也会发生同样的事情，并且在定向图时也会发生这种情况，有时我们无法到达所有节点。有时，这是我们要寻找的行为，但有时，我们希望访问所有节点。
我们将执行与DFS中相同的操作，即，只要有任何未访问的节点，我们就将继续调用BFS。我们将创建一个新breadthFirstSearchModified(Node node)方法为我们完成此任务：
void breadthFirstSearchModified(Node node) {
breadthFirstSearch(node);
for (Node n : adjacencyMap.keySet()) {
if (!n.isVisited()) {
breadthFirstSearch(n);
}
}
}
public class GraphShow {
public static void main(String[] args) {
Graph graph = new Graph(false);
Node a = new Node(0, "0");
Node b = new Node(1, "1");
Node c = new Node(2, "2");
Node d = new Node(3, "3");
Node e = new Node(4, "4");
graph.addEdge(a,d);
graph.addEdge(a,b);
graph.addEdge(c,e);
System.out.println("Using the unmodified version of BFS we get:");
graph.breadthFirstSearch(a);
graph.resetNodesVisited();
System.out.println("Using the modified version of BFS we get:");
graph.breadthFirstSearchModified(a);
}
}
输出：
Using the unmodified version of BFS we get:
0 3 1
Using the modified version of BFS we get:
0 3 1
4 2还有一种叫做“双向” BFS搜索的东西。当我们想要找到两个顶点(节点)之间的最短路径时，这很有用。
这是通过同时(在不同线程中)从起始节点和目标节点运行BFS来实现的。从理论上讲，这可以找到两个节点之间的最短路径，而这仅仅是从起始节点运行BFS的两倍。
注意：与DFS一样，如果我们要以特定顺序(而不是添加边的顺序)遍历邻居，则可以使用aPriorityQueue代替aLinkedList来邻居列表。
该代码是相同的，我们只需要执行Comparable并添加compareTo()方法给我们的Node类。
结论
图形是存储某些类型的数据的便捷方法。该概念是从数学移植而来的，适合于计算机科学的需求。
由于许多事物可以用图形表示，因此图形遍历已成为一项常见的任务，尤其是在数据科学和机器学习中。
广度优先搜索是为数不多的图形遍历算法之一，并且“逐层”访问节点。与深度优先搜索不同，BFS不会主动到达一个分支，直到到达终点为止，而是当我们从一个节点开始搜索时，它会访问该节点的所有未访问邻居，然后再访问另一个节点的所有未访问邻居。 。
译者：啊强啊
来源：Stack Abuse
