如何在非二叉树的一次递归搜索中获取节点的深度

Question

根据Recursive search for a node in non-binary tree，我知道如何实现递归搜索，但是如何获得该节点的深度？

我想我应该为每个递归添加一个计数器，但我不知道应该在哪里添加这个计数器.....

谢谢

Answer 1

这里是带有 cmets 的部分代码：

public class Tree
{
    private Node root;

    public int findDepth(int searchNodeValue) {
        List<Node> nodesAtCurrentLevel = Collections.singletonList(root);

        return recursiveSearch(0, searchNodeValue, nodesAtCurrentLevel);
    }

    public int recursiveSearch(int level, int searchNodeValue, List<Node> nodesAtCurrentLevel) {
        List<Node> nodesAtNextLevel = new ArrayList<Node>();

        // Check if searchNode matches any node at current level
        for (Node node : nodesAtCurrentLevel) {
            // If it matches, we have found the node, return current level
            if (node.getValue() == searchNodeValue) {
                return level;
            }

            // Add children of all nodes at current level in nodesAtNextLevel
            if (node.hasChildren()) {
                nodesAtNextLevel.addAll(node.getChildren());
            }
        }

        // searchNode is not found at current level, increment level and continue search at next level if next level exists in tree
        if (!nodesAtNextLevel.isEmpty()) {
            return recursiveSearch(level + 1, searchNodeValue, nodesAtNextLevel);
        }

        // We have traversed entire tree. Node not found. Return -1
        return -1;
    }
}

class Node
{
    private int value;

    private List<Node> children = new ArrayList<Node>();

    public Node(int value) {
        this.value = value;
    }

    public boolean hasChildren() {
        return children.isEmpty();
    }

    public int getValue() {
        return value;
    }

    public List<Node> getChildren() {
        return children;
    }
}

Answer 2

编辑

-- 让递归函数获得输入级别。从 0/-1 开始。返回一个对象；该对象具有节点和级别。递归函数的每次传递都会增加传入的级别并将其设置在返回对象中。

-- 将级别传递给递归函数。从 0/-1 开始。维护一个全局变量（或定义为非本地函数的变量，以便在函数的每次迭代中访问相同的变量；即变量不在堆栈上而是在堆上。我希望这件事在Java，不需要进一步解释）。在递归函数开始时将其设置为（1 + 传入级别）。这不是线程安全的。

// 原始答案的想法是将级别作为参考传递并在递归函数中增加它。显然，在 Java 中这样做很乏味。