计算每个子树中的节点答案

【问题标题】：Count nodes in each subtree计算每个子树中的节点
【发布时间】：2016-10-04 15:00:47
【问题描述】：

我需要解决一个更大的算法，其中一个步骤是计算每个子树中的节点我不需要代码来做，但我需要帮助来理解

练习是这样的：

基本上我需要返回一棵新树，每个节点都包含该节点的值，以及左子树中的元素数和右子树中的元素数。

这是方法

public AB NumberOnEachSubtree(NodeAB a,NodeAB b) {

我想我可以在第一行代码中创建子树，然后在我遍历原始树时添加每个节点，当您返回递归计数节点数时

但我不知道该怎么做.. 帮助

每个节点都有左节点和右节点以及numberNodesLeft和numberNodesRight

【问题讨论】：

事实上，树中的节点数恰好是左右子树中的节点数加上根节点的总和，这应该很容易适用于简单的递归方法。将递归方法转换为迭代方法以避免巨大树上的堆栈溢出作为练习留给读者，如果有必要处理这样的树...

标签： recursion tree

【解决方案1】：

我可以给你一个算法的伪代码：

class TreeNode
{
    integer CountLeftChildren()
    {
        integer count = 0
        if (hasLeftChildren)
        {
             foreach(child in LeftChildren)
             {
                  count++
                  child+=child.CountLeftChildren()
                  child+=child.CountRightChildren()
             }
        }
        return count
    }

    integer CountRightChildren()
    {
        integer count = 0
        if (hasRightChildren)
        {
             foreach(child in RightChildren)
             {
                  count++
                  child+=child.CountLeftChildren()
                  child+=child.CountRightChildren()
             }
        }
        return count
    }
}

希望对你有帮助...

【讨论】：

【解决方案2】：

这是 JAVA 中的解决方案。基本上，创建一个包含左节点数和右节点数的 TreeNode 类。我意识到这个答案对于 OP 来说可能为时已晚，但希望从长远来看它会对某人有所帮助。

class TreeNode{
    TreeNode left;
    TreeNode right;
    int leftNodes;
    int rightNodes;
    int value;
    public TreeNode(int value){
        value=value;
        TreeNode left = null;
        TreeNode right = null;
        leftNodes =rightNodes=0;
    }
}

public void numofRightLeftSubTree(TreeNode root){
    numNodes(root);
    System.out.println("number of left tree nodes are " + root.leftNodes );
    System.out.println("number of right tree nodes are " + root.rightNodes);

}

public int numNodes(TreeNode root) {
    if (root == null) return 0;
    int left = numNodes(root.left);
    int right = numNodes(root.right);

    root.leftNodes = left;
    root.rightNodes = right;

    return left + right + 1;
}

【讨论】：

【解决方案3】：

这是 Haskell 中的一个解决方案，因为它非常简洁，即使不熟悉该语言，您也应该能够弄清楚算法的步骤。

合适的树数据类型：

data Tree a = Nil
  | Leaf a
  | Br a (Tree a) (Tree a) deriving Show

图片中的示例树：

t = Br 3 (Br 5 Nil (Leaf 9))
          (Br 8 (Leaf 1) Nil)

递归函数，将具有整数节点的树转换为以整数三元组为节点的树。左子树和右子树的递归解在 tl 和 tr 中，count 函数对变换后的（子）树的节点进行计数。

transform :: Tree Integer -> Tree (Integer, Integer, Integer)
transform Nil = Nil
transform (Leaf a) = Leaf (0, a, 0)
transform (Br a l r) = (Br (count tl, a, count tr) tl tr)
  where tl = transform l 
        tr = transform r 

        count Nil      = 0
        count (Leaf a) = 1
        count (Br a l r) = count l + count r + 1

如果您将上述代码保存在 .hs 文件中并在 Haskell 解释器中尝试，您可以使用它。在翻译拥抱：

Main> t
Br 3 (Br 5 Nil (Leaf 9)) (Br 8 (Leaf 1) Nil)
Main> transform t
Br (2,3,2) (Br (0,5,1) Nil (Leaf (0,9,0))) (Br (1,8,0) (Leaf (0,1,0)) Nil)

我希望这可以帮助您以您选择的语言开发正确的解决方案。

【讨论】：