使用Java实现BFS算法不起作用

我正在尝试使用Java实现BFS。 我从中获得了一个代码，并对其进行了如下修改

我将要存储的字符串类型更改为对象类型。 它不起作用。如果它是一个字符串，它将工作。有人能告诉我为什么吗

我的代码如下

package bfs;

import java.util.*;

/**
 *
 * @author Harikrishnan
 */
public class BFS {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Search.execute();
    }

}

class Graph {
    private Map <Node, LinkedHashSet<Node>> map = new HashMap();

    public void addEdge(Node node1, Node node2) {
        LinkedHashSet<Node> adjacent = map.get(node1);
        if(adjacent==null) {
            adjacent = new LinkedHashSet();
            map.put(node1, adjacent);
        }
        adjacent.add(node2);
    }

    public void addTwoWayVertex(Node node1, Node node2) {
        addEdge(node1, node2);
        addEdge(node2, node1);
    }

    public boolean isConnected(Node node1, Node node2) {
        Set adjacent = map.get(node1);
        if(adjacent==null) {
            return false;
        }
        return adjacent.contains(node2);
    }

    public LinkedList<Node> adjacentNodes(Node last) {
        LinkedHashSet<Node> adjacent = map.get(last);
        if(adjacent==null) {
            return new LinkedList();
        }
        return new LinkedList<Node>(adjacent);
    }
}


class Search {

    private static final Node START = new Node("1");
    private static final Node END = new Node("4");

    public static void execute() {
        // this graph is directional
        Graph graph = new Graph();
        graph.addEdge(new Node("1"), new Node( "2"));
        graph.addEdge(new Node("2"), new Node( "1"));
        graph.addEdge(new Node("2"), new Node( "3"));
        graph.addEdge(new Node("2"), new Node( "4"));
        graph.addEdge(new Node("2"), new Node( "7"));
        graph.addEdge(new Node("3"), new Node("5"));
        graph.addEdge(new Node("3"), new Node( "6"));
        graph.addEdge(new Node("3"), new Node( "2"));
        graph.addEdge(new Node("4"), new Node( "2"));
        graph.addEdge(new Node("4"), new Node( "7"));
        graph.addEdge(new Node("4"), new Node( "8"));
        graph.addEdge(new Node("5"), new Node( "3"));
        graph.addEdge(new Node("5"), new Node( "6"));
        graph.addEdge(new Node("5"), new Node("9"));
        graph.addEdge(new Node("6"), new Node( "3"));
        graph.addEdge(new Node("6"), new Node("7"));
        graph.addEdge(new Node("6"), new Node("5"));
        graph.addEdge(new Node("6"), new Node("9"));
        graph.addEdge(new Node("7"), new Node("2"));
        graph.addEdge(new Node("7"), new Node("6"));
        graph.addEdge(new Node("7"), new Node("8"));
        graph.addEdge(new Node("7"), new Node("10"));
        graph.addEdge(new Node("8"), new Node("4"));
        graph.addEdge(new Node("8"), new Node("7"));
        graph.addEdge(new Node("8"), new Node("10"));
        graph.addEdge(new Node("9"), new Node("5"));
        graph.addEdge(new Node("9"), new Node("6"));
        graph.addEdge(new Node("9"), new Node("10"));
        graph.addEdge(new Node("10"), new Node( "9"));
        graph.addEdge(new Node("10"), new Node("7"));
        graph.addEdge(new Node("10"), new Node("8"));
        LinkedList<Node> visited = new LinkedList();
        visited.add(START);
        new Search().breadthFirst(graph, visited);
    }

    private void breadthFirst(Graph graph, LinkedList<Node> visited) {
        LinkedList<Node> nodes = graph.adjacentNodes(visited.getLast());
        // examine adjacent nodes
        for (Node node : nodes) {
            if (visited.contains(node)) {
                continue;
            }
            if (node.equals(END)) {
                visited.add(node);
                printPath(visited);
                visited.removeLast();
                break;
            }
        }
        // in breadth-first, recursion needs to come after visiting adjacent nodes
        for (Node node : nodes) {
            if (visited.contains(node) || node.equals(END)) {
                continue;
            }
            visited.addLast(node);
            breadthFirst(graph, visited);
            visited.removeLast();
        }
    }

    private void printPath(LinkedList<Node> visited) {
        for (Node node : visited) {
            System.out.print(node);
            System.out.print(" ");
        }
        System.out.println();
    }
}

class Node
{
    public String name;
    public int x;
    public int y;

    public Node(String name)
    {
        this.name = name;
    }

    @Override
    public String toString()
    {
        return name;
    }

    @Override
    public boolean equals(Object n)
    {
        return ((Node)n).name.equals(name);
    }
}

包bfs；
导入java.util.*；
/**
*
*@作者哈里克里希南
*/
公共类BFS{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
Search.execute（）；
}
}
类图{
私有映射映射=新的HashMap（）；
公共无效添加（节点1、节点2）{
LinkedHashSet nexture=map.get（node1）；
如果（相邻==null）{
相邻=新LinkedHashSet（）；
地图放置（节点1，相邻）；
}
添加（node2）；
}
公共void addTwoWayVertex（节点1、节点2）{
附录（节点1、节点2）；
附录（节点2、节点1）；
}
公共布尔值未连接（节点1、节点2）{
设置相邻=map.get（node1）；
如果（相邻==null）{
返回false；
}
返回相邻的.contains（node2）；
}
公共LinkedList邻接节点（最后一个节点）{
LinkedHashSet nexture=map.get（最后一个）；
如果（相邻==null）{
返回新的LinkedList（）；
}
返回新的LinkedList（相邻）；
}
}
类搜索{
私有静态最终节点开始=新节点（“1”）；
私有静态最终节点端=新节点（“4”）；
公共静态void execute（）{
//这个图形是有方向的
图形=新图形（）；
图.附录（新节点（“1”）、新节点（“2”）；
图.附录（新节点（“2”）、新节点（“1”）；
图.附录（新节点（“2”）、新节点（“3”）；
图.附录（新节点（“2”）、新节点（“4”）；
图.附录（新节点（“2”）、新节点（“7”）；
图.附录（新节点（“3”）、新节点（“5”）；
图.附录（新节点（“3”）、新节点（“6”）；
图.附录（新节点（“3”）、新节点（“2”）；
图.附录（新节点（“4”）、新节点（“2”）；
图.附录（新节点（“4”）、新节点（“7”）；
图.附录（新节点（“4”）、新节点（“8”）；
图.附录（新节点（“5”）、新节点（“3”）；
图.附录（新节点（“5”）、新节点（“6”）；
图.附录（新节点（“5”）、新节点（“9”）；
图.附录（新节点（“6”）、新节点（“3”）；
图.附录（新节点（“6”）、新节点（“7”）；
图.附录（新节点（“6”）、新节点（“5”）；
图.附录（新节点（“6”）、新节点（“9”）；
图.附录（新节点（“7”）、新节点（“2”）；
图.附录（新节点（“7”）、新节点（“6”）；
图.附录（新节点（“7”）、新节点（“8”）；
图.附录（新节点（“7”）、新节点（“10”）；
图.附录（新节点（“8”）、新节点（“4”）；
图.附录（新节点（“8”）、新节点（“7”）；
图.附录（新节点（“8”）、新节点（“10”）；
图.附录（新节点（“9”）、新节点（“5”）；
图.附录（新节点（“9”）、新节点（“6”）；
图.附录（新节点（“9”）、新节点（“10”）；
图.附录（新节点（“10”）、新节点（“9”）；
图.附录（新节点（“10”）、新节点（“7”）；
图.附录（新节点（“10”）、新节点（“8”）；
已访问LinkedList=新建LinkedList（）；
已访问。添加（开始）；
新搜索（）.breadthFirst（图形，已访问）；
}
private void BroadthFirst（图形，已访问的链接列表）{
LinkedList节点=graph.adjacentNodes（visted.getLast（））；
//检查相邻节点
用于（节点：节点）{
if（已访问.包含（节点））{
继续；
}
if（节点等于（结束））{
添加（节点）；
printPath（已访问）；
removeLast（）；
打破
}
}
//在广度优先中，递归需要在访问相邻节点之后进行
用于（节点：节点）{
如果（已访问.包含（节点）| |节点.等于（结束））{
继续；
}
addLast（节点）；
广度第一（图表，访问）；
removeLast（）；
}
}
私有void打印路径（已访问LinkedList）{
for（节点：已访问）{
系统输出打印（节点）；
系统输出打印（“”）；
}
System.out.println（）；
}
}
类节点
{
公共字符串名称；
公共int x；
公共智力；
公共节点（字符串名称）
{
this.name=名称；
}
@凌驾
公共字符串toString（）
{
返回名称；
}
@凌驾
公共布尔等于（对象n）
{
返回（（节点）n）.name.equals（名称）；
}
}

你的代码让我有点困惑，让我们看看我对它的理解

首先，既然你已经有了一个非常好的搜索实例，为什么还要创建一个新的搜索实例呢？使

execute（）

成为构造函数。将

newsearch（）.execute（）

更改为just

execute（）

其次，您是否也打算创建具有相同编号的新节点或重用相同的节点，因为在我看来，似乎所有内容都链接到单个节点，而不是我假设您想要的内容，并将节点彼此链接，并将所有内容链接到解析它。你不知道；甚至不包括根节点

---

如果这是你想要的，请原谅我。正如我所说，你的代码让我困惑。

请比“不工作”更具体一些。实际上它没有给出任何输出。没有打印任何内容。然后我建议您将这些信息放入问题中。除了这些信息之外，如果您使用调试工具/步进程序一行一行地检查代码，并尝试查看出错的地方，这将非常有用。