二叉树的高度是从根节点到最远离根节点的子节点的距离。

下面是一个示例：

           2 <-- root: Height 1
          / \
         7   5 <-- Height 2
        / \   \
       2   6   9 <-- Height 3
          / \  /
         5  11 4 <-- Height 4 

二叉树的高度：4

二叉树的定义

树是一个对象，其中包含一个带符号的整数值以及另外两个树或指向它们的指针。

二叉树结构的结构如下所示：

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

挑战：

输入值

二叉树的根

输出量

代表二叉树高度的数字

假设您将二叉树的根作为输入，编写最短的程序来计算二叉树的高度并返回高度。字节数最少的程序（占空格）获胜。

果冻，3 个字节

ŒḊ’

一个Monadic链接，该列表接受一个表示树：的列表[root_value, left_tree, right_tree]，其中left_tree和中的每个right_tree都是相似的结构（如果需要，则为空），产生高度。

在线尝试！

怎么样？

果冻里的小事：

ŒḊ’ - Link: list, as described above
ŒḊ  - depth
  ’ - decremented (since leaves are `[value, [], []]`)

Python 2中， 35个  33字节

感谢Arnauld提出监督并节省了4。

f=lambda a:a>[]and-~max(map(f,a))

一个递归函数，它接受一个表示tree：的列表[root_value, left_tree, right_tree]，其中left_tree和中的每个right_tree都是相似的结构（如果需要，则为空），该结构返回高度。

在线尝试！

^{请注意，[]它将返回False，但使用Python False==0。}

Haskell，33个字节

h L=0 
h(N l r _)=1+max(h l)(h r)

使用自定义树类型data T = L | N T T Int，这是质询中给定的C结构的Haskell等效项。

在线尝试！

Perl 6，25个字节

{($_,{.[*;*]}...*eqv*)-2}

输入是一个三元素列表(l, r, v)。空树是空列表。

在线尝试！

说明

{                       }  # Anonymous block
    ,        ...  # Sequence constructor
  $_  # Start with input
     {.[*;*]}  # Compute next element by flattening one level
               # Sadly *[*;*] doesn't work for some reason
                *eqv*  # Until elements doesn't change
 (                   )-2  # Size of sequence minus 2

旧解决方案，30字节

{+$_&&1+max map &?BLOCK,.[^2]}

在线尝试！

05AB1E，11 7 5 字节

Δ€`}N

-4个字节，感谢@ExpiredData。
-2个字节感谢@Grimy。

输入格式类似于Jelly答案：表示树的列表：[root_value, left_tree, right_tree]，其中left_tree和right_tree都是相似的结构（可选为空）。即[2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]]代表挑战说明中的树。

在线尝试或验证更多测试用例。

说明：

Δ     # Loop until the (implicit) input-list no longer changes:
  €`  #  Flatten the list one level
}N    # After the loop: push the 0-based index of the loop we just finished
      # (which is output implicitly as result)

请注意，尽管05AB1E是基于0的，但changes循环Δ使输出索引正确，因为它需要额外的迭代才能检查它是否不再更改。

JavaScript（ES6）， 35  33字节

输入结构： [[left_node], [right_node], value]

f=([a,b])=>a?1+f(f(a)>f(b)?a:b):0

在线尝试！

已评论

f =                       // f is a recursive function taking
([a, b]) =>               // a node of the tree split into
                          // a[] = left child, b[] = right child (the value is ignored)
  a ?                     // if a[] is defined:
    1 +                   //   increment the final result for this branch
    f(                    //   and add:
      f(a) > f(b) ? a : b //     f(a) if f(a) > f(b) or f(b) otherwise
    )                     //
  :                       // else:
    0                     //   stop recursion and return 0

C，43个字节

h(T*r){r=r?1+(int)fmax(h(r->l),h(r->r)):0;}

二叉树的结构如下：

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

JavaScript（Node.js），32字节

f=a=>/,,/.test(a)&&f(a.flat())+1

在线尝试！

使用名称flat代替flatten或是smoosh代码高尔夫的好主意。

使用[]在树空节点，并[left, right, value]为节点。value这是一个整数。

Wolfram语言（Mathematica），10个字节

Depth@#-2&

在线尝试！将输入作为嵌套列表{v, l, r}。

Haskell，28个字节

使用以下数据定义：

data T a = (:&) a [T a]

高度为：

h(_:&x)=foldr(max.succ.h)0 x

方案，72字节

(define(f h)(if(null? h)0(+ 1(max(f(car(cdr h)))(f(car(cdr(cdr h))))))))

更易读的版本：

(define (f h)
   (if (null? h)
      0
      (+ 1 
         (max
             (f (car (cdr h)))
             (f (car (cdr (cdr h))))
         )
      )
   )
)

使用表单列表（数据，左，右）来表示树。例如

   1
  / \
  2  3
 /\
 4 5

is represented as: (1 (2 (4 () ()) (5 () ())) (3 () ())

(1
   (2
      (4 () ())
```   (5 () ())
   (3 () ())
)

在线尝试！

R，51字节

function(L){while(is.list(L<-unlist(L,F)))T=T+1;+T}

在线尝试！

• 输入：格式为的嵌套列表：list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• 算法：将树迭代地平展一个级别，直到它成为平面向量：迭代次数对应于最大深度。

受到@KevinCruijssen解决方案的启发

递归替代：

R，64字节

`~`=function(L,d=0)'if'(is.list(L),max(L[[2]]~d+1,L[[3]]~d+1),d)

在线尝试！

重新定义函数/运算符'~'，使其能够计算存储在列表结构中的树的最大深度。

树的列表结构的格式为： list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• -2感谢@Giuseppe

Japt，8字节

@eU=c1}a

尝试一下

原始的9个字节

Ω¡ÒßXÃrw

尝试一下

K（ngn / k），4个字节

解：

#,/\

在线尝试！

说明：

我想我可能错过了重点。

将树表示为3项列表（父节点；左子节点；右子节点），示例可以表示为

(2;
  (7;
    (,2);
    (6;
      (,5);
      (,11)
    )
  );
  (5;
    ();
    (9;
      (,4);
      ()
    )
  )
)

要么： (2;(7;(,2);(6;(,5);(,11)));(5;();(9;(,4);())))。

因此，解决方案是迭代展平，并计算迭代次数：

#,/\ / the solution
   \ / iterate
 ,/  / flatten
#    / count

木炭，29字节

⊞θ⁰⊞υθＦυ«≔⊕⊟ιθＦΦι∧κλ⊞υ⊞Ｏκθ»Ｉθ

在线尝试！链接是详细版本的代码。在处理期间临时修改树。说明：

⊞θ⁰

将零推送到根节点。

⊞υθ

将根节点推送到所有节点的列表。

Ｆυ«

对树执行宽度优先搜索。

≔⊕⊟ιθ

获取此节点的深度。

ＦΦι∧κλ

循环遍历任何子节点。

⊞υ⊞Ｏκθ

告诉子节点其父节点的深度，然后将其推入所有节点的列表。

»Ｉθ

遍历所有节点后，将打印最后一个节点的深度。由于遍历是广度优先，因此这就是树的高度。

Stax，5 个字节

▐▌µ╡⌂

运行并调试

Stax既没有指针也没有null值，所以我将输入表示为[2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]]。也许这是一个不公平的优势，但这是我可以获得的最接近的优势。

解压，解压和注释，代码看起来像这样。

        The input starts on top of the input stack
Z       Tuck a zero underneath the top value in the stack.  Both values end up on the main stack.
D       Drop the first element from array
F       For each remaining element (the leaves) run the rest of the program
  G^    Recursively call the entire program, then increment
  T     Get maximum of the two numbers now ow the stack

运行这个

Kotlin，45个字节

val Tree.h:Int get()=1+maxOf(l?.h?:0,r?.h?:0)

假设定义了以下类别

class Tree(var v: Int, var l: Tree? = null, var r: Tree? = null)

在线尝试

朱莉娅，27个字节

f(t)=t≢()&&maximum(f,t.c)+1

使用以下表示二进制树的结构：

struct Tree
    c::NTuple{2,Union{Tree,Tuple{}}}
    v::Int
end

c是表示左节点和右节点的元组，空元组()用于表示不存在节点。

Kotlin，42个字节

fun N.c():Int=maxOf(l?.c()?:0,r?.c()?:0)+1

在线尝试！

哪里

data class N(val l: N? = null, val r: N? = null, val v: Int = 0)