ALBERI_ESERCIZI_2_DA SOLO

PARENTETICA-SIMMETRICA((t) //stampa l'albero
PARENTETICARIC(t.root);

PARENTETICARIC(t)
if(t==NULL)
	return;
else
	if(PARENTETICARIC(t.left)==FALSE)
		PRINT("t.info");
		return;
	else
		PARENTETICARIC(t.left);
		PARENTETICARIC(t.right);
		return;

--------------------------------------------------------------------
PARENTETICA-PREORDINE(t)
PARENTETICARIC(t.root)

PARENTETICARIC(n)
	if(n==null)
		return
	else
		print("(")
		PARENTETICARIC(n.left);
		print(n.info);
		PARENTETICARIC(n.right);
		print (")");
		return;
------------------------------------------------------------------------------
//CHIEDI se giusto
VALORE-NONNO(t)
	if(t.root==null)
		return 0;
	return VALORERIC(t.root)

VALORE-RIC(t)
	if(t==null)
		return 0;
	else
		cont =(CALCOLAVALORE(t.left.left, t.info) + CALCOLAVALORE(t.right.right, t.info)+CALCOLAVALORE(t.left.right, t.info)+CALCOLAVALORE(t.right.left, t.info);
		cont = cont+VALORERIC(t.left);
		cont = cont+VALORERIC(t.right);
		return cont;

CALCOLAVALORE(,n)
	if(t==null)
		return 0;
	if(n==t.info)
		return 1;
	else
		return 0;

------------------------------------------------------------------------------
//CHIEDI se giusto
DUE-FIGLI(t)
return DUE-FIGLIRIC(t.root)

DUE-FIGLIRIC(n)
	if(t==null)
		return 0;
	else
		if(T.left!=null && t.right!=NULL)
			return cont = 1+DUE-FIGLI(t.left)+DUE-FIGLI(t.right);
		if(t.left!=NULL)
			return DUE-FIGLI(t.left);
		else
			return DUE-FIGLI(t.right);

--------------------------------------------------------------------------

QUATTRO-NIPOTI(t)
	return 	QUATTRO-NIPOTI-RIC(t.root);

QUATTRO-NIPOTI-RIC(t)
	if(t==null)
		return 0;
	if(t.left!=null && t.right!=null){
		k = DUE-FIGLI(t.right)+DUE-FIGLI(t.left);
		return k+QUATTRONIPOTI(t.left)+QUATTRONIPOTI(t.right);
	}
	return QUATTRONIPOTI(t.left)+QUATTRONIPOTI(t.right);

DUE-FIGLI-Versione-2(t)
	if(t==null)
		return 0;
	if(t.left!=NULL && t.right!=NULL)
		return 1
	return 0;

--------------------------------------------------------------------------------

CAMMINO(t, n)
	//L è una nuova lista doppiamente concatenata
	L = CAMMINO-RIC(t.root, n)
	if(L!==NULL)
		l.head = NULL;
		return l;
	return L;

CAMMINO-RIC(t, n)
	if(t==NULL)
		return NULL;
	if(t.info==n);
		l.head = NULL;
		temp.info = u;
		temp.prev =NULL;
		temp.next=NULL;
		l.head = temp;
		return l;
	l = CAMMINO-RIC(t.left, n)
	r = CAMMINO-RIC(t.right, n)
	if(l!=NULL)
		temp.info = t.info;
		AggiungiInTesta(L, temp)
		return L;
	if(r!=NULL)
		temp.info=t.info;
		AggiungiInTesta(L, temp)
		return L
	return NULL;
}

AggiungiInTesta(L, n)
	if(l.head == NULL)
		//temp è un nuovo nodo
		temp.info = n;
		temp.prev =null;
		temp.next =NULL;
		L.head = temp;
		return l;
	temp.info = n;
	temp.next = l.head;
	temp.prev = NULL;
	l.head.prev = temp;
	l.head = temp;
	return l;


----------------------------------------------------------------------------------------------------

PARENTELA(n1,n2){
	//t è l'albero considerato
	L1 = CAMMINO(T, n1);
	L2 = CAMMINO(T, N2)
	return SCORRI-LISTE(L1, L2);
}

SCORRI-LISTE(L1, L2) //ritorna un numero con la lunghezza dei cammini delle due liste.
	while(L1==L2 && L1!=NULL && L2!=null){
			L1 = L1.next
			L2 = L2.next;
		}
		ContL1 = 0;
		ContL1 = 0;
		if(L1!=NULL)
			ContL1 = CONTA-RIMANENTE(L1);
		if(L2!=NULL)
			ContL2 = CONTA-RIMANENTE(L1);
		return ContL1+ContL2;

CONTA-RIMANENTE(L){
	temp = L;
	while(temp!=NULL)
		cont++
		temp = temp.next;
	return cont;