Question

我需要帮助计算二叉树高度的理论，通常是符号。

我已阅读以下文章：

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

height（node）= max（height（node.L），height（node.R））+ 1

假设我有以下二叉树：

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

我是否计算左边节点（8）的最大值和右边的最大节点（42），然后加1？我不太明白这种符号是如何工作的，以便计算树的高度。

Answer 1

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

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)

因此，如果要计算height(10)，则必须向下扩展递归，而不是向后替换结果。

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

编辑：

如评论中所述：
的 height of binary tree = number of layers - 1
因此，应该假设空节点的高度等于-1，即：

height(empty) = -1

或

height(null) = -1

这样

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

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

Answer 2

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

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

Answer 3

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

Answer 4

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

Answer 5

从第一个节点（ROOT）开始到叶节点的方式中可能存在的最大节点数称为树的高度。找到树高的公式h = i（max）+1，其中h是树的高度，I是树的最高层

Answer 6

#include<stdio.h>
#include<stdlib.h>


/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
struct node 
{
    int data;
    struct node* left;
    struct node* right;
};

/* Compute the "maxDepth" of a tree -- the number of 
    nodes along the longest path from the root node 
    down to the farthest leaf node.*/
int maxDepth(struct node* node) 
{
   if (node==NULL) 
       return 0;
   else
   {
       /* compute the depth of each subtree */
       int lDepth = maxDepth(node->left);
       int rDepth = maxDepth(node->right);

       /* use the larger one */
       if (lDepth > rDepth) 
           return(lDepth+1);
       else return(rDepth+1);
   }
} 

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data) 
{
    struct node* node = (struct node*)
                                malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;

    return(node);
}

int main()
{
    struct node *root = newNode(1);

    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5); 

    printf("Hight of tree is %d", maxDepth(root));

    getchar();
    return 0;
}

Answer 7

重复提问

尽管对递归有很好的介绍，但我对所有关于二叉树高度的错误答案感到有些惊讶，所以我认为我提供了正确的解决方案。我做了一些挖掘，这个问题在这里得到了正确回答：https://stackoverflow.com/a/2597754/5567854。

<强>参考

根据Wikipedia，＆＃34;仅由根节点组成的树的高度为0＆＃34;而不是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);
}

Answer 8

您可以使用递归方法。

int height（节点根）{
return root == null？ 0：Math.max（height（root.left），height（root.right））+1;
}

Answer 9

在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中的库。

Answer 10

C enthousiasts，请随时阅读本文：

http://www.csegeek.com/csegeek/view/tutorials/algorithms/trees/tree_part3.php

我重新安排了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

计算二叉树的高度

10 个答案: