Data structures 计算二叉树的高度

我需要有关计算二叉树高度的理论的帮助，通常是表示法

我读了以下文章：

其中一个帖子给出了以下符号：

高度（节点）=最大值（高度（节点L）、高度（节点R））+1

假设我有以下二叉树：

     10
   /   \  
  5    30
 / \   /  \ 
4  8  28  42

---

因此，我是否计算左侧节点（8）和右侧节点（42）上的最大值，然后加1？我不太明白这个符号是如何计算树的高度的

树的高度是从根到树中最深节点的路径长度。下面是最短的算法

int height(Node root){
   if(root == null )
       return 0;
   return 1+max{height(root.left), height(root.right)};
}

---

我将尝试解释此递归算法的工作原理：

height(10) = max(height(5), height(30)) + 1

height(30) = max(height(28), height(42)) + 1
height(42) = 0 (no children)
height(28) = 0 (no children)

height(5) =  max(height(4), height(8)) + 1
height(4) = 0 (no children)
height(8) = 0 (no children)

因此，如果要计算高度（10），必须向下展开递归，然后向后替换结果

height(5)  = max(0, 0) + 1
height(30) = max(0, 0) + 1
height(10) = max(1, 1) + 1
height(10) = 2

编辑：

如评论中所述：

二叉树高度=层数-1

因此，应假设空节点的高度等于-1，即：

height(empty) = -1 

或

这边

height(42) = max(height(null), height(null)) + 1
height(42) = max(-1, -1) + 1
height(42) = -1 + 1
height(42) = 0

---

我已经更正了上面的计算。

你知道节点高度的定义吗？我的回答是到可到达叶的最远距离（因此所有叶的高度都为0）…现在尝试从下到上查找每个节点的高度..这将是您的算法

找出根节点，然后查找您可以覆盖的最长路径（表示您可以在该路径中覆盖的最大节点数）， 如果你得到了那条路径，那么检查你覆盖了多少分支或边缘，

---

您覆盖的分支总数是树的高度

从第一个节点（根）到叶节点的最大节点数称为树的高度。求一棵树的高度的公式h=i（max）+1，其中h是树的高度，i是树的最大高度，请阅读本文：

我将C代码重新排列到PHP：

function getTreeHeight($node) {
    if (!isset($node['left']) && !isset($node['right'])) {
        return 0;
    }

    $leftHeight  = getTreeHeight($node['left']);
    $rightHeight = getTreeHeight($node['right']);

    if ($leftHeight > $rightHeight) {
        return $leftHeight + 1;
    } else {
        return $rightHeight + 1;
    }
}

$array = array(
    'value' => 5,
    'left' => array(
        'value' => 2,
        'left' => array(
            'value' => 1,
        ),
        'right' => array(
            'value' => 4
        ),
    ),
    'right' => array(
        'value' => 11,
        'left' => array(
            'value' => 7
        ),
        'right' => array(
            'value' => 23,
            'left' => array(
                'value' => 16
            ),
            'right' => array(
                'value' => 34
            ),
        ),
    )
);

echo getTreeHeight($array); //output 3

#包括
#包括
/*二叉树节点有数据，指针指向左边的子节点
和一个指向正确孩子的指针*/
结构节点
{
int数据；
结构节点*左；
结构节点*右；
};
/*计算树的“maxDepth”——树的
从根节点开始沿最长路径的节点
向下到最远的叶节点*/
int maxDepth（结构节点*节点）
{
if（node==NULL）
返回0；
其他的
{
/*计算每个子树的深度*/
int lDepth=maxDepth（节点->左侧）；
int rDepth=maxDepth（节点->右侧）；
/*用大一点的*/
如果（lDepth>rDepth）
返回（lDepth+1）；
否则返回（rDepth+1）；
}
} 
/*使用
给定数据和空的左指针和右指针*/
结构节点*新节点（整型数据）
{
结构节点*节点=（结构节点*）
malloc（sizeof（struct node））；
节点->数据=数据；
节点->左=空；
节点->右=空；
返回（节点）；
}
int main（）
{
结构节点*root=newNode（1）；
根->左=新节点（2）；
根->右=新节点（3）；
根->左->左=新节点（4）；
根->左->右=新节点（5）；
printf（“树的高度为%d”，最大深度（根））；
getchar（）；
返回0；
}

重复问题

尽管是递归的很好的介绍，我还是对所有关于二叉树高度的错误答案感到有点惊讶，所以我认为我应该提供正确的解决方案。我做了一些挖掘，这个问题在这里得到了正确的回答：

参考

根据“仅由根节点组成的树的高度为0”，而不是1作为另一种状态。因此，以问题为例：

     10
   /   \  
  5    30
 / \   /  \ 
4  8  28  42

如果10是查找该树高度的根节点，则高度为2，而不是3

正确的代码

此解决方案是C语言中许多可能的解决方案之一

size_t binary_tree_height(const binary_tree_t *tree)
{
    size_t r, l, height = 0;

    if (tree)
    {
        r = tree->right ? binary_tree_height(tree->right) + 1 : 0;
        l = tree->left ? binary_tree_height(tree->left) + 1 : 0;
        height += (r > l ? r : l);
    }
    return (height);
}

---

您可以使用递归方法

---

int height（Node root）{
return root==null？0:Math.max（height（root.left）、height（root.right））+1；
}

在Java的用户定义二叉树中，二叉树高度的递归方法如下所示-

class Node
{
    int data;
    Node left, right;
    public Node(int item)
    {
        data = item;
        left = right = null;
    }

    boolean isLeaf() { return left == null ? right == null : false; }
}

public class BinaryTree {
    Node root;
    public BinaryTree() {
        root = null;
    }
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root= new Node(1);
        tree.root.left= new Node(2);
        tree.root.right= new Node(3);
        tree.root.left.left= new Node(4);
        tree.root.left.right= new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);
        tree.root.right.left.left = new Node(8);
        tree.root.right.left.right = new Node(9);
        System.out.println("\n Height of tree is : "+tree.height(tree.root)); 
    }

    /*Height of Binary tree*/
  public int height(Node root) {
        if (root == null)
            return 0;
        else {
            int lHeight = height(root.left);
            int rHeight = height(root.right);

            if (lHeight > rHeight)
                return (lHeight + 1);
            else return (rHeight + 1);
        }
    }
}

---

使用上述代码，您可以轻松创建二叉树，而无需使用java中的库。

这是一种递归算法<代码>高度调用自身，直到它到达树的每个分支的底部。我要补充的是，当它到达底部时，它会检查高度是否大于现有存储的高度，如果大于，则更新它。@ChrisChambers感谢您的回复。因此，我们是将

节点.L

乘以

节点.R

当前树的高度，例如，给定的树的高度是多少？@Phorce:我们没有将任何东西相乘。node.L指节点的左子节点。当前树的高度为2I建议在插入树时将树的高度设置为树类的属性。也就是说，每次插入时，检查并查看您是否在树下走得更远，如果是，则更新高度。这个问题对我的实验室作业有很大帮助……计算左右高度的最大值的目的是什么？@Riptyde4您在上面看到的树具有相同的高度，可以向左走，也可以向右走。但想想这样的情况，例如。在原始示例中，在数字28下方附加数字6。这就是为什么我们必须得到最大值。这个答案很好地解释了递归，但它错误地计算了二叉树的高度。递归的结束（当输入节点=

NULL

时）应该返回

-1

而不是

0

。我已经提供了正确的答案。作为参考，这是一个重复的问题，另一个堆栈溢出问题也有正确的答案，@kimbaudi有一个基本条件来检查是否存在子级或子级

size_t binary_tree_height(const binary_tree_t *tree)
{
    size_t r, l, height = 0;

    if (tree)
    {
        r = tree->right ? binary_tree_height(tree->right) + 1 : 0;
        l = tree->left ? binary_tree_height(tree->left) + 1 : 0;
        height += (r > l ? r : l);
    }
    return (height);
}

class Node
{
    int data;
    Node left, right;
    public Node(int item)
    {
        data = item;
        left = right = null;
    }

    boolean isLeaf() { return left == null ? right == null : false; }
}

public class BinaryTree {
    Node root;
    public BinaryTree() {
        root = null;
    }
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root= new Node(1);
        tree.root.left= new Node(2);
        tree.root.right= new Node(3);
        tree.root.left.left= new Node(4);
        tree.root.left.right= new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);
        tree.root.right.left.left = new Node(8);
        tree.root.right.left.right = new Node(9);
        System.out.println("\n Height of tree is : "+tree.height(tree.root)); 
    }

    /*Height of Binary tree*/
  public int height(Node root) {
        if (root == null)
            return 0;
        else {
            int lHeight = height(root.left);
            int rHeight = height(root.right);

            if (lHeight > rHeight)
                return (lHeight + 1);
            else return (rHeight + 1);
        }
    }
}