Questo file non va usatp per nutrire il programma ...
Per scrivere una rappresentazione parentetica "dal nulla" bisogna seguire un minimo di disciplina, altrimenti per alberi un po' profondi si rischia il mal di testa ...

Qui si vede una resa grafica (testuale) della rappresentazione parenteteica, che aiuta a svilupparla, cioe` a scriverla ...

primo passo: disegnare l'albero sulla carta.
Fatelo per conto vostro; inventate un albero che contenga 16 nodi, non troppo sbilanciato
 
nel seguito provo a scrivere un albero binario con caratteri che vanno da A a Z, 
sono 16 caratteri distribuiti in un sottolabero sinistro di 6 caratteri (visto a laezione) e un destro con radice U e altri 9 caratteri.
Stiamo sviluppando l'albero come "di ricerca", cosi` la visita simmetrica sara` carina.
Ma non e obbligatorio. Fate come volete.
... Certo e` piu` carino ...

Magari fate questa cosa due volte, una con un albero generico e un'altra con un binario di ricerca.

									M
					D										U
			B				F						S				X	
		A		C		E					Q			T		W		Y	
										P		R							Z

e per cominciare si scrive solo la radice e si indica dove si sviluppera` il sottoalbero sinistro e dove quello destro
										
( M
  SIN
  DES
)

secondo passo (il SIN lo abbiamo visto a lezione e dovremmo averlo usato per le prove precedenti di questo programma ...)
( M
   ( D
     ( B( A()())( C()()))
	 ( F( E()())())
	)
   DES di M
)

usare un editor in cui ci sia "syntax coloring", e le parentesi corrispondenti vengano evidenziate con un colore: e` comodo.
Ad esempio usando notepad++ (non l'orrido notepad di windoze) se metto il cursore subito a destra della parentesi alla linea 23, la vedo colorata di verde, insiema a quella di linea 18.
Questo e` utile per riuscire a far corrispondere le parentesi ... quando studiavo io queste cose non c'erano ed era molto peggio ...

terzo passo: sviluppiamo un po' il DES di M; 
U e` la radice, S e` la radice del sottoalbero sinistro di U 
e poi c'e` il DES di U

( M
   ( D
     ( B( A()())( C()()))
	 ( F( E()())())
    )
   ( U
      ( S
	     SIN di S
         DES di S 
      )
	  DES di U
   )
)




quarto passo
aggiungiamo il sottoalbero sinistro del nodo che contiene S (il modello e` il SIN di D)
( M
   ( D
     ( B( A()())( C()()))
	 ( F( E()())())
    )
   ( U
      ( S
	     ( Q( P()())( R()()))
         DES di S 
      )
	  DES di U
   )
)


quinto passo
aggiungiamo il sottoalbero destro di S (singleton T) e iniziamo il des di U

( M
   ( D
     ( B( A()())( C()()))
	 ( F( E()())())
    )
   ( U
      ( S
	     ( Q( P()())( R()()))
         ( T()())
      )
	  ( X
	     SIN di X 
		 DES di X
      )
    )
)


sesto passo
aggiungiamo il sottoalbero destro di S (singleton T) e completiamo il des di U (che ha come SIN il singleton W e come DES un sottoalbero con radice Y, sinistro vuoto e sigleton Z come destro).
Verifichiamo che le parentesi restanti siano chiuse bene.  

( M
   ( D
     ( B( A()())( C()()))
	 ( F( E()())())
    )
   ( U
      ( S
	     ( Q( P()())( R()()))
         ( T()())
      )
	  ( X
         ( W()())
         ( Y()( Z()()))
      )
    )
)


PASSO FINALE
La costruzione sopra e` stata utile per riuscire ad arrivare in fondo senza troppi danni; pero` l'albero scritto cosi` ha troppi spazi e andate a capo per essere usato con gli algoritmi che abbiamo visto a lezione (che sono implementati in questo esercizi).
Quindi bisogna togliere le indentazioni e le andate a capo, stando attenti a non lasciare spazio tra la radice e i sottoalberi, o tra i sottoalberi ... l'unico spazio che serve qui e` quello tra la '(' e l'info da mettere nella radice.

( M( D( B( A()())( C()()))( F( E()())()))( U( S( Q( P()())( R()()))( T()()))( X( W()())( Y()( Z()())))))


NB
Se vogliamo usare nel programma la strutturazione con indentazioni e andate a capo bisogna modificare un po' le funzioni di lettura dal file.
Non e` difficile e diventa importante se arriviamo a gestire alberi con TipoInfo complesso (come Volo o Persona).
Qui non facciamo questa modifica, ma farlo e` un esercizio molto utile. 
Fatelo!