Question

正如标题中所述，我试图通过仅计算BST中具有左右子节点的节点来解决此问题。我很难想到解决这个问题的逻辑。

我想到了这样的事情。

首先，检查root是否为null或者是否有任何null子项。接下来，遍历正确的树并继续检查子项，在满足条件时递增计数器。但是当我到达终端节点并需要返回到有一个左子进行遍历的节点时会发生什么？我有一个临时节点来跟踪最先前的父节点，但是当我需要上升多个级别时呢？我假设这个问题的答案是递归地解决它，但我甚至不知道从哪里开始。

这就是我所拥有的：

public int fullNodes() {
    int count = 0;
    Node n = root;
    Node temp = null;

    if (n == null || n.left == null && n.right == null) return count;

    count++; //increment count, since the root has children on both sides

    temp = n; //hold the previous place
    n = n.right; //go right

    //Now what?

    return count;
}

在问题解决时，我仍然在努力思考，除了我的问题，你如何学会递归思考？只是大量的练习，还是有一些技巧和提示，你用来解决问题？

Answer 1

而不是使用临时变量来保存前一个节点 - 这只适用于1的深度 - 在子节点上调用相同的函数。

递归树遍历可能如下所示：

public int countSomething (Node node) {

    // Self;
    //   
    int result = 1;   // use your required logic here

    // Children;
    //    
    if (node.left != null)
        result += countSomething( node.left);
    if (node.right != null)
        result += countSomething( node.right);

    // done.
    return result;
}


// example usages
int treeTotal = countSomething( rootNode);
int subtreeTotal = countSomething( subtree);

然后执行调用栈将保存函数的递归调用，每个调用都有适当的上下文。当顶级调用返回时，它将总计调用它的整个树/或子树的答案。

为您的BST“节点有左右儿童”输入适当的逻辑，而不是常数1.

Answer 2

首先让我们创建Node类的表示

class Node {
    public Node left;
    public Node right;
    public Node(){}
    public Node(Node left, Node right) {
        this.left = left;
        this.right = right;
    }
}

然后我们编写我们的recusrive函数和使用您的函数的客户端

public class Main {   

    public static int countNodes(Node root) {
        if(root!=null && root.left!=null && root.right!=null) {
            return 1+countNodes(root.left)+countNodes(root.right);
        }
        return 0;
    }

    public static void main(String[] args) {
        Node right = new Node();
        Node left = new Node();
        Node root = new Node(left, right);
        root.right = new Node(new Node(), new Node());
        System.out.println(countNodes(root));
    }

}

BST - 计算具有左右子项的节点

2 个答案: