I pocit, že jste správně položil otázku. Pokusím se odpovědět na otázku, jak je možné uvažovat o realizaci iterativní verze na objednávku průchod (I jen náhodou dali tuto nějakou myšlenku a realizovány ji teprve nedávno. Cítím, že bude sám pomoci i tím, že toto dole ), za předpokladu, že člověk ví, rekurzivní verzi.
Každé volání funkce v rekurzivní verzi se snaží navštívit uzel spojený s volání funkce. Funkce je kódována tak, že aktivace rám, odpovídající uzlu, je uložena na systém zásobníku (stack prostoru tohoto procesu), před tím, než se může provést jeho hlavní práce, tj navštívit uzel. Je tomu tak proto, že chceme navštívit levý podstrom uzlu před návštěvou uzel sám.
Poté, co se na levý podstrom, návrat k rámu našich uložených výsledků uzel v jazykovém prostředí praskání stejný z vnitřního zásobníku a při návštěvě našeho uzlu je nyní povoleno.
Musíme napodobovat to tlačit a praskání s explicitním stack.
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;
}
}
}
Nejlepší způsob, jak pochopit, je to k tomu fungování vnitřního zásobníku na papír na každé volání a vrácení rekurzivní verzi.
