Sento che non hai fatto la domanda in modo corretto. Cercherò di rispondere alla domanda su come si può pensare di attuare la versione iterativa di attraversamento in-order (Ho appena capita di aver dato questo qualche pensiero e realizzato molto di recente. Mi sento io a trattenermi troppo, mettendo questo in giù ) dato che si conosce la versione ricorsiva.
Ogni chiamata di funzione in una versione ricorsiva cerca di visitare il nodo associato con la chiamata di funzione. La funzione è codificata in modo tale che l'attivazione-frame corrispondente ad un nodo viene salvata nella pila sistema (area pila di tale processo) prima che possa fare il suo compito principale, cioè il nodo visitare. Questo è così perché vogliamo visitare il sottoalbero sinistro del nodo prima di visitare il nodo stesso.
Dopo la sottostruttura sinistra è visitato, un ritorno al telaio dei nostri risultati nodo salvati nell'ambiente lingua schioccare la stessa dalla pila interna e una visita al nostro nodo è ora consentito.
Dobbiamo imitare questo spingere e popping con uno stack esplicito.
template<class T>
void inorder(node<T> *root)
{
// The stack stores the parent nodes who have to be traversed after their
// left sub-tree has been traversed
stack<node<T>*> s;
// points to the currently processing node
node<T>* cur = root;
// Stack-not-empty implies that trees represented by nodes in the stack
// have their right sub-tree un-traversed
// cur-not-null implies that the tree represented by 'cur' has its root
// node and left sub-tree un-traversed
while (cur != NULL || !s.empty())
{
if (cur != NULL)
{
for (; cur->l != NULL; cur = cur->l) // traverse to the leftmost child because every other left child will have a left subtree
s.push(cur);
visit(cur); // visit him. At this point the left subtree and the parent is visited
cur = cur->r; // set course to visit the right sub-tree
}
else
{// the right sub-tree is empty. cur was set in the last iteration to the right subtree
node<T> *parent = s.top();
s.pop();
visit(parent);
cur = parent->r;
}
}
}
Il modo migliore per capire questo è quello di disegnare il funzionamento della pila interna su carta per ogni chiamata e di ritorno della versione ricorsiva.
