Ik heb het gevoel heb je de vraag niet goed gesteld. Ik zal proberen om de vraag hoe men kan denken over de uitvoering van de iteratieve versie van in-orde traversal te beantwoorden (ik toevallig dit enige gedachte te hebben gegeven en geïmplementeerd het zeer onlangs. Ik voel dat ik zal zelf ook helpen door te zetten deze naar beneden ) gezien het feit dat men de recursieve versie kent.
Elke functie oproep in een recursieve versie streeft naar het knooppunt in verband met de functie-oproep te bezoeken. De functie wordt zodanig gecodeerd dat activering frame overeenkomt met een knooppunt wordt opgeslagen in het systeem stapel (stack gebied dat proces) vóór het zijn belangrijkste werk kan doen, dat wil zeggen dan de knoop. Dit is zo omdat we willen de linker deelboom van het knooppunt te bezoeken voor een bezoek aan het knooppunt zelf.
Nadat de linker deelboom wordt bezocht, is een terugkeer naar het kader van onze opgeslagen knooppunt resultaten in de taalomgeving popping hetzelfde van de interne stack en een bezoek aan onze knooppunt nu toegestaan.
We hebben na te bootsen dit duwen en knallen met een expliciete 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;
}
}
}
De beste manier om dit te begrijpen is om de werking van de interne stapel op papier te tekenen op elke oproep en de terugkeer van de recursieve versie.
