Scrivi il programma più breve per verificare se un albero binario è bilanciato


15

Per ogni nodo in un albero binario bilanciato, la differenza massima nelle altezze della sottostruttura figlio sinistra e della sottostruttura figlio destra sono al massimo 1.

L'altezza di un albero binario è la distanza dal nodo radice al figlio nodo più lontano dalla radice.

Di seguito è riportato un esempio:

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

Altezza dell'albero binario: 4

Di seguito sono riportati gli alberi binari e un rapporto sull'equilibrio o meno:

Caso di prova 1

L'albero sopra è sbilanciato .

Caso di prova 2

L'albero sopra è bilanciato .

Scrivi il programma più breve possibile che accetta come input la radice di un albero binario e restituisce un valore di falso se l'albero è sbilanciato e un valore di verità se l'albero è bilanciato.

Ingresso

La radice di un albero binario. Questo può essere sotto forma di un riferimento all'oggetto radice o anche di un elenco che è una rappresentazione valida di un albero binario.

Produzione

Restituisce il valore di verità: se l'albero è bilanciato

Restituisce il valore false: se l'albero non è bilanciato.

Definizione di un albero binario

Un albero è un oggetto che contiene un valore e altri due alberi o puntatori ad essi.

La struttura dell'albero binario è simile alla seguente:

typedef struct T
{
   struct T *l;
   struct T *r;
   int v;
}T;

Se si utilizza una rappresentazione di elenco per un albero binario, potrebbe essere simile al seguente:

[root_value, left_node, right_node]

2
L'input può essere albero vuoto?
TSH

1
Nel tuo esempio iniziale di albero, se rimuovi la foglia 4, l'albero rimanente è bilanciato?
Neil,

No, non quell'esempio, intendevo quello iniziale, usando l'arte ASCII.
Neil,

Secondo la mia implementazione "C, 117 byte": No, poiché l'altezza dell'albero secondario secondario a partire da "5" è 2 e l'altezza dell'albero secondario secondario è 0.
T. Salim

Le modifiche sono almeno 6 caratteri, ma si prega di rimuovere la virgola tra 'bilanciato' e 'binario' - 'albero binario' è una frase di nome, quindi scrivere 'albero binario bilanciato' è l'equivalente di 'rosso, mobile della neve' - il la virgola non è richiesta.
Geza Kerecsenyi,

Risposte:


8

Gelatina , 11 byte

ḊµŒḊ€IỊ;߀Ạ

Provalo online!

L'albero vuoto è rappresentato da [].


Grazie Erik per essere stato tra i primi a rispondere a questa domanda. Jelly è sicuramente una lingua molto popolare su questo sito. Penso che dovrei prendermi la libertà di implementare questo linguaggio. Buono da imparare da un robusto linguaggio di scripting di golf.
T. Salim,

Complimenti Erik l'Outgolfer, sei il vincitore.
T. Salim,

3

Prolog (SWI) , 49 byte

N+_/B/C:-X+B,Y+C,abs(X-Y)<2,N is max(X,Y)+1.
0+e.

Provalo online!

Rappresenta gli alberi come Value/Left_Child/Right_Child, con l'albero vuoto che è l'atomo e. Definisce +/2, che genera in esito positivo o negativo, con una variabile non associata (o una già uguale all'altezza dell'albero) a sinistra e l'albero a destra - se l'argomento altezza è inaccettabile, aggiungere 9 byte per definire -T:-_+T..

N + _/B/C :-            % If the second argument is a tree of the form _Value/B/C,
    X+B,                % X is the height of its left child which is balanced,
    Y+C,                % Y is the height of its right child which is balanced,
    abs(X-Y) < 2,       % the absolute difference between X and Y is strictly less than 2,
    N is max(X,Y)+1.    % and N is the height of the full tree.
0 + e.                  % If, on the other hand, the second argument is e, the first is 0.

(Se il valore di ciascun nodo potesse essere omesso dall'input, _/potrebbe essere eliminato per -2 byte.)
Stringa non correlata

3

Wolfram Language (Mathematica) , 50 byte

f@_[x_,y_]:=f@x&&f@y&&-2<Depth@x-Depth@y<2;f@_=1>0

Utilizzare Nullper null, value[left, right]per nodi. Ad esempio, il seguente albero è scritto come 2[7[2[Null, Null], 6[5[Null, Null], 11[Null, Null]]], 5[Null, 9[4[Null, Null], Null]]].

    2
   / \
  7   5
 / \   \
2   6   9
   / \  /
  5  11 4

Provalo online!


È davvero carino!
Greg Martin,

3

Python 3.8 (pre-release) , 133 125 byte

b=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1)
h=lambda t:b(t)[1]

Provalo online!

Accetta un albero nel formato "elenco": un nodo è [value, left, right]con lefted rightessendo nodi.

Richiama la funzione h.

Restituisce 0o Falseper un albero sbilanciato. Restituisce 1o Trueper un albero bilanciato.

Ungolfed:

# Returns tuple (current height, subtrees are balanced (or not))
def balanced(tree):
  if tree: # [] evaluates to False
    left = balanced(tree[1])
    right = balanced(tree[2])
    # If  the subtrees are not both balanced, nothing to do, just pass it up
    if left[1] and right[1]:
      height = max(left[0], right[0]) + 1
      subtrees_balanced = abs(left[0] - right[0]) < 2
    else:
      height = 0 # Value doesn't matter, will be ignored
      subtrees_balanced = False
  else:
    height = 0
    subtrees_balanced = True
  return (height, subtrees_balanced)

def h(tree):
  return balanced(tree)[1]

-10: logica invertita per sbarazzarsi di nots

Se è consentito accettare argomenti nel mezzo di una chiamata, è possibile accorciarlo a (115 byte)

(b:=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1))(_)[1]

con _essere l'albero da controllare.



2

JavaScript, 162 byte

f=x=>{for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1];if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}return 1}

Provalo online!

Il formato dell'input è un oggetto

root={a:{node},b:{node},c:value}

Spiegazione

for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1]

Eseguendo l'ampiezza della prima ricerca, trova la profondità del primo nodo a cui mancano uno o più rami.

if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}

Continuando la prima ricerca della larghezza, restituisce zero se qualsiasi elemento è due più profondo della profondità dei rami mancanti del primo nodo.

return 1}

Se tale nodo non viene trovato, restituisce 1


1
C'è probabilmente un modo per fare meglio l'ampiezza della prima ricerca, ma non ci ho pensato.
fəˈnɛtɪk,

1
Penso che questo fallisca per alcuni casi validi come il primo esempio che dovrebbe essere bilanciato quando si rimuove la foglia 4.
Neil,

1

Julia, 56 byte

f(t)=t!=()&&(-(f.(t.c)...)^2<2 ? maximum(f,t.c)+1 : NaN)

Con la seguente struttura che rappresenta l'albero binario:

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

cè una tupla che rappresenta i nodi sinistro e destro e la tupla vuota ()viene utilizzata per segnalare l'assenza di un nodo.

Il valore di Falsey è NaN, qualsiasi numero intero è veritiero.


1
Supponendo che la codifica sia UTF-8, si tratta in realtà di 57 byte a causa del , secondo il contatore di byte integrato di TIO . Comunque, benvenuto in CG&CC!
Corda non correlata

1
Sì hai ragione. L'ho corretto, in modo che ora sia effettivamente 56 byte
user3263164

0

Kotlin , 67 byte

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

Dove

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

Provalo online!


0

C, 117 byte

h(T*r){r=r?1+h(h(r->l)>h(r->r)?r->l:r->r):0;}b(T*r){return r->l&&!b(r->l)||r->r&&!b(r->r)?0:abs(h(r->l)-h(r->r))<=1;}

L'implementazione di Struct è la seguente:

 typedef struct T
    {
        struct T * l;

        struct T * r;

        int v;

    } T;

Prova questo su JDoodle


Questo sembra essere 117 byte, anche se invece puoi fare <2per quell'ultimo controllo
Jo King

Inoltre, non sono sicuro di quanto sia valido, dal momento che si basa su una struttura di dati definita al di fuori della presentazione
Jo King

0

Python 2 , 99 96 94 byte

lambda A:A==[]or(abs(D(A[1])-D(A[2]))<2)*f(A[1])*f(A[2])
D=lambda A:A>[]and-~max(map(D,A[1:]))

Provalo online!

3 byte da Jo King .

Prende l'input come: nodo vuoto è []e altri nodi lo sono [<value>, <leftNode>, <rightNode>]. Uscite 0/1per False / True.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.