Java中具有2个子节点以上的树的深度优先搜索

我有一个应用程序，它有一个树结构，其中每个父节点有3个或更多子节点。每个节点包含一个整数值。我试图查看树中是否存在给定的整数值。如何在树上执行深度优先搜索？我知道我们从根开始，然后在树的每个分支中尽可能地探索。不过，我在用Java实现这一点时遇到了困难。我是否需要某种其他数据结构来进行遍历

如果有人能给出一个示例实现，那将是很有帮助的

树结构如下所示。我需要实现findNode函数：

public class Tree{

    public Node{

        Node [] children;
        int val;

        public Node[] getChildren(){
            return children;
        }

        public getVal(int i){
            return children[i].val;
        } 

    }

    public boolean findNode(int val){


    }

}

迭代：

public boolean findNode(Node node, int value) {
  Deque<Node> stack = new ArrayDeque<Node>();
  stack.push(node);
  while (!stack.isEmpty()) {
    Node n = stack.pop();
    if (n.getVal() == value)
      return true;
    for (Node child : n.getChildren())
      stack.push(child);
  }
  return false;
}

您不需要

getVal（inti）

方法。节点参数是树的根。

迭代：

public boolean findNode(Node node, int value) {
  Deque<Node> stack = new ArrayDeque<Node>();
  stack.push(node);
  while (!stack.isEmpty()) {
    Node n = stack.pop();
    if (n.getVal() == value)
      return true;
    for (Node child : n.getChildren())
      stack.push(child);
  }
  return false;
}

---

您不需要

getVal（inti）

方法。node参数是树的根。

未测试，但至少显示了算法的结构。如果您想要BFS，只需将

堆栈

替换为

链接列表

public boolean findNodeDFS(Node root, int value) {
    Stack<Node> nodes = new Stack<>(){{
      add(root);  
    }};
    while (!nodes.isEmpty()) {
        Node current = nodes.pop();

        if (current.getValue() == value) {
            return true;
        }
        nodes.addAll(Arrays.asList(current.getChildren()));
    }
    return false;
}

public boolean findNodeDFS（节点根，int值）{
堆栈节点=新堆栈（）{{
添加（根）；
}};
而（！nodes.isEmpty（））{
当前节点=nodes.pop（）；
if（current.getValue（）==value）{
返回true；
}
nodes.addAll（Arrays.asList（current.getChildren（））；
}
返回false；
}

未测试，但至少显示算法的结构。如果您想要BFS，只需将

堆栈

替换为

链接列表

public boolean findNodeDFS(Node root, int value) {
    Stack<Node> nodes = new Stack<>(){{
      add(root);  
    }};
    while (!nodes.isEmpty()) {
        Node current = nodes.pop();

        if (current.getValue() == value) {
            return true;
        }
        nodes.addAll(Arrays.asList(current.getChildren()));
    }
    return false;
}

public boolean findNodeDFS（节点根，int值）{
堆栈节点=新堆栈（）{{
添加（根）；
}};
而（！nodes.isEmpty（））{
当前节点=nodes.pop（）；
if（current.getValue（）==value）{
返回true；
}
nodes.addAll（Arrays.asList（current.getChildren（））；
}
返回false；
}

您的问题表明您已经实现了树。请提供所用结构的代码，以便在示例代码中使用。DFS和BFS基本上是相同的算法。当在没有递归的情况下实现时，它们之间的唯一区别是一个使用

堆栈

，另一个使用

队列

。如果这是生产代码而不是学习练习，请看一看Guava的TreeTraverser。您的问题表明您已经实现了树。请提供所用结构的代码，以便在示例代码中使用。DFS和BFS基本上是相同的算法。当在没有递归的情况下实现时，它们之间的唯一区别是一个使用

堆栈

，另一个使用

队列

。如果这是生产代码而不是学习练习，看看Guava的TreeTraverser，你能提供一个迭代实现吗？你需要使用堆栈来模拟递归行为。是的，我想知道怎么做。有可能提供这种实现吗？我已经添加了一个使用Deque接口（）的实现。你能提供一个迭代实现吗？你需要使用堆栈来模拟递归行为。是的，我想知道怎么做。有可能提供这种实现吗？我添加了一个使用Deque接口（）的实现