Algo_it(T,h){
	ret=-1;
	curr=T;
	s=0;
	d=0;
	stack_curr=NIL;
	stack_s=NIL;
	last=NIL;
	while(curr!=NIL || stack_curr!=NIL){
		if(curr!=NIL){
			if(curr->sx!=NIL || curr->dx!=NIL){				//uso questo if per poter ottenere lo stesso risultato dell'algo ric
				if(curr->sx!=NIL){							//quando un nodo dell'albero non ha figli.
					push(stack_curr,curr);
					h++;
					ret=-1;						//inizializzo variabili ad ogni discesa.
					s=0;
					d=0;
					curr=curr->sx;
				}else if(curr->dx!=NIL){
						push(stack_curr,curr);
						push(stack_s,s);				//se scendo a destra salvo s nello stack_s.
						h++;
						ret=-1;						//inizializzo variabili ad ogni discesa.
						s=0;
						d=0;
						curr=curr->dx;
					}
			}else{								//in questo caso specifico un nodo non ha figli e quindi eseguo le oper.
				if(s=0 && d=0)						//dell'algo ric.
					ret=h;
				else
					ret=s+d;
				last=curr;
				curr=NIL;
				POP(stack_curr);
			}
		}else{
			curr=top(stack_curr);
			h--;											//non uso uno stack per H dato che quest'ultimo nell'algo ric. viene
			if(curr->dx!=NIL && curr->dx!=last){			// incrementato all'interno della chiamata e non con un'istruzione
				push(stack_curr,curr);						// esplicita all'interno del codice.
				s=ret;										//quindi quando scendo lo incremento, quando risalgo lo decremento.
				push(stack_s,s);
				ret=0;										// se devo scendere a destra salvo s nello stack_s.
				s=0;
				d=0;
				h++;
				curr=curr->dx;
			}else{
				if(curr->dx!=NIL){
					s=top(stack_s);							//se salgo da destra allora s lo trovo nello stack_s mentre d=ret
					d=ret;									// perchè è l'ultimo valore aggiornato.
					POP(stack_s);
				}else{
					s=ret;									//se a destra nn ho figli allora s=ret mentre d=0 e nn -1 perchè
					d=0;									//a destra nn scendo e quindi d rimarrà uguale a 0, cioè al valore
				}											//inizializzato.
				if(s=0 && d=0)
					ret=h;
				else										//Operazioni dell'algo ric.
					ret=s+d;
				last=curr;
				curr=NIL;
				POP(stack_curr);
			}
		}
	}
return ret;
}