Question

如果您在没有任何参数的情况下声明它，您将如何计算BST的深度。我知道你可以像参数一样：

public class BST {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
       int left=maxDepth(root.left);
       int right=maxDepth(root.right);
       return Math.max(left,right)+1;
   }

}

但是没有这样的参数可以做到这一点：

public int maxDepth(){}

如果我们可以从方法中访问BST的根及其左右子节点？

Answer 1

来自问题和许多猜测的信息很少：

    public int maxDepth() {
        return maxDepth(root);
    }

其余代码：

public class BST {
    public int maxDepth() {
        return maxDepth(root);
    }

    public int maxDepth(final TreeNode root) {
        if (root == null)
            return 0;
        final int left = maxDepth(root.left);
        final int right = maxDepth(root.right);
        return Math.max(left, right) + 1;
    }

    public TreeNode root;

    public static class TreeNode {
        public TreeNode left, right;
    }
}

Answer 2

您要求将递归算法重写为迭代形式。

一般解决方案是堆栈。

在这种情况下，我们使用堆栈来跟踪当前节点。我们通过将currentNode放到parent堆栈来遍历树。这使parent.peek()成为当前节点。

如果我们逐层遍历树，我们需要的第二个信息是下一个要访问的节点。为此，我们使用第二个堆栈（它代表您的函数的内部状态）。第二个堆栈存储下一步（左，右，下）。

它看起来很复杂，但是我们必须手工完成一些事情，它隐藏在任何编程语言的函数堆栈中。 Stack.pop对应于函数返回。 Stack.push为下一次迭代准备参数。

我们最终得到以下程序：

import java.util.Stack;

public class BST {

    static class TreeNode {
        TreeNode right, left;
    }

    TreeNode root;

    static final int LEFT = 1;
    static final int RIGHT = 2;
    static final int UP = 3;

    public int maxDepth() {

        if (root == null)
            return 0;

        Stack<TreeNode> parent = new Stack<>();
        Stack<Integer> nextTurn = new Stack<>();

        int max = 0;

        parent.push(root); // parent.peek() is the currentNode.
                            // parent.size() is the current depth
        nextTurn.push(LEFT);
        while (!parent.isEmpty()) {
            switch (nextTurn.pop()) {
            case LEFT: // descend left (both subtrees left)
                nextTurn.push(RIGHT);
                if (parent.peek().left != null) {
                    parent.push(parent.peek().left);
                    nextTurn.push(LEFT);
                }
                break;
            case RIGHT: // descend right (left subtree done)
                nextTurn.push(UP);
                if (parent.peek().right != null) {
                    parent.push(parent.peek().right);
                    nextTurn.push(LEFT);
                }
                break;
            case UP: // go up (both subtrees done)
                if (parent.peek().left == null && parent.peek().right == null) {
                    // counting happens here.
                    // we are leaving a leaf node.
                    max = Math.max(max, parent.size());

                }
                parent.pop();
                break;
            }

        }
        return max;
    }

    public static void main(String[] args) {
        // small test:
        BST me = new BST();
        me.root = new TreeNode();

        me.root.left = new TreeNode();
        me.root.right = new TreeNode();

        me.root.left.left = new TreeNode();
        me.root.left.right = new TreeNode();
        me.root.left.left.right = new TreeNode();

        me.root.left.left.right.right = new TreeNode();

        System.out.println(me.maxDepth());

    }

}

以不同方式计算BST的深度

2 个答案: