Siento que no has hecho la pregunta correctamente. Voy a tratar de responder a la pregunta de cómo se puede pensar en la implementación de la versión iterativa de recorrido en orden (lo que pasa es que han dado a esto algún pensamiento y la práctica se hace muy poco tiempo. Siento que te ayudaré yo también poniendo esto abajo ) dado que se conoce la versión recursiva.
Cada llamada a la función en una versión recursiva busca para visitar el nodo asociado con la llamada de función. La función se codifica de tal manera que la activación de trama correspondiente a un nodo se guarda en la pila del sistema (zona de apilamiento de ese proceso) antes de la que puede hacer su trabajo principal, es decir, visitar el nodo. Esto es así porque queremos visitar el subárbol izquierdo del nodo antes de visitar el propio nodo.
Después se visita el subárbol izquierdo, ahora se permite un retorno a la estructura de nuestros resultados nodo guardados en el entorno de idioma apareciendo el mismo de la pila interna y una visita a nuestro nodo.
Tenemos que imitar este empujando y haciendo estallar con una pila explícita.
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;
}
}
}
La mejor manera de entender esto es dibujar el funcionamiento de la pila interna en el papel en cada llamada y devolución de la versión recursiva.
