[C] Albero binario, lettura in order

[}gu|do[z]{®©]

Salve.. dfondamentalmente non è un problema di codice ma di algoritmo.
Per un progettino dell'uni ho dovuto gestire un albero binario che mi ordina alfabeticamente delle parole.. e fin qui no problem.

Il problema sorge quando invece di dover stampare la listta ordinata delle parole, dovrei solo compiere un'operazione nel main per ognuna di esse... onde per cui mi servirebbe una funzione che restituisca di volta in volta un elemento dell'albero, con visita in order.

Avendo già un algoritmo iterativo (per requisito) che visitava l'albero inorder stampando le parole in output. Questo algoritmo usa una lista per riconoscere i nodi già visitati e non visitarli nuovamente.. a questo punto ho pensato che mi basta restituire la lista, creata con aggiunte in coda, per avere un ordine alfabetico delle parole nel main.. non dovendovi fare ricerche ma dovendo solo scorrere più volte l'elenco credo che sia la cosa migliore, no?
Solo che a quel punto la creazione dell'albero (servita ad ordinare una serie di parole lette da file) è stata inutile.. potevo gestirmi un vettore ordinato... no?

L'albero era un requisito del progetto quindi lo chiedo solo a titolo di curiosità.. infondo al prof interessa farci giocare con quante più strutture possibili, non essere efficienti

[unomichisiada]

Secondo me è più elegante lavorare direttamente sull'albero per effettuare operazioni sui nodi dell'albero ad uno ad unopo nell'ordeine indotto dalla visita inorder.a questo proposito ti allego due funzioncine iterative (come servono a te) che ho scritto io stesso in c che ti restituiscono il successore ed il predecessore di un certo nodo dato dell'albero.l'unica cosa è che le due funzioni ausialiarie minimum e maximum le avevo scritte ricorsive ed ora non ho il tempo di convertirle in iterative, ma farlo è una stupidata,puoi provvedere da te.spero di esserti stato utile,ciao

              
Node* minimum(Node* T)
{          /*minimo senza confrontare le chiavi*/
	Node *minim;
		if(T==NULL)
			return T;
		if(T->leftchild==NULL)
		{
			minim=T;
			return minim;
		}
		else
			return minimum(T->leftchild);
}

Node *successor(Node *x)
{                                   /*se il successore è stato inserito dopo*/
	Node *h;                    /*è il più piccolo tra i più grandi di x*/
	if(x->rightchild!=NULL)                
		return minimum(x->rightchild); 
	h=x->father;
	while(h!=NULL&&x==h->rightchild)
	{                                /*se è stato inserito prima allora*/ 
		x=h;                     /*x è il più grande dei suoi figli*/
		h=h->father;            /*più piccoli quindi si risale fino*/ 
	}                                /*a trovare un figlio sinistro */
	return h;                        /*di suo padre o la radice*/
}

Node *maximum(Node *T)       /*simmetrica alla funzione minimum*/
{
	Node *max;
		if(T==NULL)
			return T;
		if(T->rightchild==NULL)
		{
			max=T;
			return max;
		}
		else
			return maximum(T->rightchild);
}

Node *predecessor(Node *x)    /*simmetrica a successor*/
{      
	Node *h;
	if(x->leftchild!=NULL)                   
		return maximum(x->leftchild); 
	h=x->father;
	while(h!=NULL&&x==h->leftchild)
	{          
		x=h;                               
		h=h->father;                       
	}                                          
	return h;
}