Question

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

练习是这样的：

enter image description here

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

这是方法

public AB NumberOnEachSubtree（NodeAB a，NodeAB b）{

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

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

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

Answer 1

这是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;
}

Answer 2

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

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
    }
}

希望它有所帮助...

Answer 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)

递归函数，将具有Integer节点的树转换为具有Trgers三元组作为节点的树。递归解决方案在左和右子树的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)

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

计算每个子树中的节点

3 个答案: