iteratív postorder elmozdulási BST?

szavazat
-1

Két kérdésem van, 1) minden rekurzív algoritmus létezik egy iteratív algoritmus, igaz? Azt hiszem, ez így van, mert akkor csak ki kell használni a verem explicit.And azt is megerősítik ezt a kérdést út, hogy menjen a rekurziót iterációs

2) valószínűleg ugyanaz a kérdés, mint a fenti egyik, igazán dont gondol az iteratív megoldás kézenfekvő, vagy könnyű írni, még a rekurzív algoritmus. Például: egy postorder (LRN), vagy írhat elő (LNR) BST elmozdulási, hogyan írsz, iteratív módszer? Ebben a két esetben, ez nem könnyű megtalálni az első objektumot beilleszteni a verem. Ez az, ahol elakadtam.

Valami javaslat? Valójában az én célja ugyanaz, mint a fenti kérdés, meg kell találnia egy általános mintát változtatni rekurzív algoritmust iteratív is.

A kérdést 24/05/2011 08:45
a forrás felhasználó
Más nyelveken...                            


1 válasz

szavazat
0

Úgy érzem, hogy nem a kérdést megfelelően. Megpróbálok válaszolni a kérdésre, hogy hogyan lehet gondolni végrehajtási iteratív változata in-sorrendben bejárás (én csak az történik, hogy adott erre egy gondolat és hajtotta végre a közelmúltban. Úgy érzem, segít magam is azzal, hogy ezt le ), mivel az egyik ismeri a rekurzív változata.

Minden függvényhívása rekurzív változata igyekszik fel a csomóponthoz kapcsolódó függvényhívás. A funkció kódolt, hogy az aktiválással megfelelő keret egy csomópontot menti fel a rendszer verem (stack terület a folyamat), mielőtt a meg tudja csinálni a fő feladat, azaz keresse fel a csomópontot. Ez azért van így, mert azt akarjuk, hogy látogassa meg a bal részfa a csomópont felkeresése előtt maga a csomópont.

Miután a bal részfa látogatott, a visszatérés a keret a mi mentett csomópont eredmények a nyelvi környezetben felbukkanó azonos a belső szint és egy látogatás a csomópont most hagyjuk.

Van, hogy utánozzák ennek a nyomásnak, és popping egy explicit verem.

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;
        }
    }
}

A legjobb módja annak, hogy megértsük ennek az, hogy felhívja a működését a belső köteg papíron minden hívás és visszatérés a rekurzív változata.

Válaszolt 24/05/2011 15:31
a forrás felhasználó

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more