递归二叉搜索树的深度

Question

这是家庭作业，请勿发布代码。请和谢谢。

我受命创建一种计算 BST 中特定深度的方法。

为此，我要@Override 一个方法public int depth(T data)。所以，要递归地找到它，我需要创建一个辅助方法。

我知道我需要在树中搜索包含我正在寻找的数据的节点。因此，为此，我编写了以下代码：

@Override
public int depth(T data) {
    if (data == null) {
        throw new IllegalArgumentException("Data is null");
    }
    if (compare(data, root.getData()) == 0) {
        return 1;
    } else {
        return countNodes(search(root, data), data);
    }
}

private int countNodes(BSTNode<T> node, T data) {
    int depth = 1;
    if (node == null) {
        return 0;
    } else {
        if (compare(data, node.getData()) == 0) {
            return depth;
        } else if (compare(data, node.getData()) < 0) {
            return countNodes(node.getLeft(), data);
        } else {
            return countNodes(node.getRight(), data);
        }
    }
}

private int compare(T a, T b) {
    return a.compareTo(b);
}

但是，这是行不通的，因为每次进行递归调用时，depth 将保持为1；本质上，它正在重置深度的值。我不知道如何在调用之间保持depth 的值。

Answer 1

如果当前节点是您正在寻找的节点，您的 depth 方法应该返回 1，或者如果您需要继续寻找，则下一个节点的深度加 1。

例如：

                        N5
                    N3      N7
                  N1  N4  N6

你想知道 N1 的深度。

你从根开始：

N1 != N5 所以你返回一加你对 N3 的检查结果。 (1 + (N3 检查结果))

N1 != N3 所以你返回一加你对 N1 的检查结果。 (1 + (1 + (N1 检查的结果)))

N1 == N1 所以你返回一个。 (1 + (1 + (1)))

(1 + (1 + (1))) = 3

这是正确的深度，也是初始深度调用将返回的值。