A altura de uma árvore binária é a distância do nó raiz ao filho do nó que está mais distante da raiz.

Abaixo está um exemplo:

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

Altura da árvore binária: 4

Definição de uma árvore binária

Uma árvore é um objeto que contém um valor inteiro assinado e duas outras árvores ou ponteiros para eles.

A estrutura da estrutura da árvore binária é semelhante à seguinte:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

O desafio:

Entrada

A raiz de uma árvore binária

Resultado

O número que representa a altura de uma árvore binária

Supondo que você receba a raiz de uma árvore binária como entrada, escreva o programa mais curto que calcula a altura de uma árvore binária e retorna a altura. O programa com menos quantidade de bytes (espaços em branco de contabilidade) vence.

Gelatina , 3 bytes

ŒḊ’

Um link monádico que aceita uma lista que representa a árvore:, [root_value, left_tree, right_tree]onde cada uma left_treee right_treesão estruturas semelhantes (vazias, se necessário), que produzem a altura.

Experimente online!

Quão?

Bastante trivial em Jelly:

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

Python 2 ,  35  33 bytes

Agradecimentos a Arnauld por perceber e supervisionar 4.

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

Uma função recursiva que aceita uma lista que representa a árvore:, [root_value, left_tree, right_tree]onde cada uma left_treee right_treesão estruturas semelhantes (vazias, se necessário), que retornam a altura.

Experimente online!

^{Observe que []retornará False, mas em Python False==0.}

Haskell, 33 bytes

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

Usando o tipo de árvore customizada data T = L | N T T Int, que é o equivalente Haskell da estrutura C fornecida no desafio.

Experimente online!

Perl 6 , 25 bytes

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

Entrada é uma lista de 3 elementos (l, r, v). A árvore vazia é a lista vazia.

Experimente online!

Explicação

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

Solução antiga, 30 bytes

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

Experimente online!

05AB1E , 11 7 5 bytes

Δ€`}N

-4 bytes graças a @ExpiredData .
-2 bytes graças a @Grimy .

O formato de entrada é semelhante ao da resposta Jelly: uma lista que representa a árvore:, [root_value, left_tree, right_tree]onde cada uma left_treee right_treesão estruturas semelhantes (opcionalmente vazias). Ou seja, [2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]]representa a árvore a partir da descrição do desafio.

Experimente online ou verifique mais alguns casos de teste .

Explicação:

Δ     # 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)

Observe que, embora 05AB1E seja baseado em 0, o loop de alterações Δfaz com que o índice de saída esteja correto, pois precisa de uma iteração adicional para verificar se não muda mais.

JavaScript (ES6),  35  33 bytes

Estrutura de entrada: [[left_node], [right_node], value]

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

Experimente online!

Comentado

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 bytes

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

Estrutura da árvore binária é a seguinte:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

JavaScript (Node.js) , 32 bytes

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

Experimente online!

Usar o nome em flatvez de flattenou smooshé uma ótima idéia para o código de golfe.

Usando []para nó nulo na árvore e [left, right, value]para nós. valueaqui é um número inteiro.

Wolfram Language (Mathematica) , 10 bytes

Depth@#-2&

Experimente online! Recebe entrada como uma lista aninhada {v, l, r}.

Haskell, 28 bytes

Usando a seguinte definição de dados:

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

A altura é:

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

Esquema, 72 bytes

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

Versão mais legível:

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

Usando listas do formulário (dados, esquerda, direita) para representar uma árvore. Por exemplo

   1
  / \
  2  3
 /\
 4 5

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

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

Experimente Online!

R , 51 bytes

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

Experimente online!

• Entrada: uma lista aninhada no formato:list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• Algoritmo: Nivela a árvore iterativamente em um nível até que se torne um vetor plano: a contagem de iterações corresponde à profundidade máxima.

Inspirado na solução @KevinCruijssen

Alternativa recursiva:

R , 64 bytes

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

Experimente online!

Redefine a função / operador, '~'permitindo calcular a profundidade máxima de uma árvore armazenada em uma estrutura de lista.

A estrutura da lista de uma árvore está no formato: list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• -2 graças a @Giuseppe

Japonês , 8 bytes

@eU=c1}a

Tente

Original, 9 bytes

Ω¡ÒßXÃrw

Tente

K (ngn / k) , 4 bytes

Solução:

#,/\

Experimente online!

Explicação:

Eu acho que posso ter entendido errado.

Representando uma árvore como a lista de 3 itens (nó pai; filho esquerdo; filho direito), o exemplo pode ser representado como

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

ou: (2;(7;(,2);(6;(,5);(,11)));(5;();(9;(,4);()))).

Portanto, a solução é achatar iterativamente e contar as iterações:

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

Carvão , 29 bytes

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

Experimente online! Link é a versão detalhada do código. Modifica temporariamente a árvore durante o processamento. Explicação:

⊞θ⁰

Empurre zero para o nó raiz.

⊞υθ

Envie o nó raiz para a lista de todos os nós.

Ｆυ«

Faça uma pesquisa pela primeira vez da árvore.

≔⊕⊟ιθ

Obtenha a profundidade desse nó.

ＦΦι∧κλ

Faça um loop sobre qualquer nó filho.

⊞υ⊞Ｏκθ

Diga ao nó filho a profundidade do pai e envie-o para a lista de todos os nós.

»Ｉθ

Uma vez percorridos todos os nós, imprima a profundidade do último nó. Como a travessia foi a primeira da largura, essa será a altura da árvore.

Stax , 5 bytes

▐▌µ╡⌂

Execute e depure

Stax não tem ponteiros nem valores nulos, então eu represento a entrada como [2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]]. Talvez seja uma vantagem injusta, mas foi a mais próxima que pude chegar.

Descompactado, não jogado e comentado, o código fica assim.

        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

Execute este

Kotlin, 45 bytes

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

Supondo que a seguinte classe esteja definida

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

Experimente online

Julia, 27 bytes

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

Com a seguinte estrutura representando a árvore binária:

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

cé uma tupla que representa os nós esquerdo e direito e a tupla vazia ()é usada para sinalizar a ausência de um nó.

Kotlin , 42 bytes

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

Experimente online!

Onde

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