iteracyjny postorder trawers BST?

głosy
-1

Mam dwa pytania 1) dla dowolnego algorytmu rekurencyjnego, istnieje algorytm iteracyjny, czy to prawda? Myślę, że to dobrze, bo po prostu trzeba użyć stosu explicit.And potwierdza się w tej kwestii sposób, aby przejść od rekursji do iteracji

2) prawdopodobnie to samo pytanie jak powyżej jednego, naprawdę nie sądzę iteracyjny rozwiązanie jest oczywiste lub łatwe do napisania nawet z algorytmem rekurencyjnym. Na przykład: dla postorder (LRN) lub Inorder (BST) LNR biegu, w jaki sposób można napisać go metodą iteracyjną? W tych dwóch przypadkach, to nie jest łatwe do znalezienia pierwszego obiektu wstawić do stosu. To miejsce, gdzie utknąłem.

Jakieś sugestie? Faktycznie, mój cel jest taki sam jak na powyższe pytanie, spróbuj znaleźć ogólny wzór na zmianę algorytmu rekurencyjnego do nich iteracyjnych.

Utwórz 24/05/2011 o 08:45
źródło użytkownik
W innych językach...                            


1 odpowiedzi

głosy
0

Czuję, że nie zadał pytanie poprawnie. Postaram się odpowiedzieć na pytanie, w jaki sposób można myśleć o wdrażaniu iteracyjną wersję na zamówienie przechodzenie (ja akurat dały tej refleksji i wdrożono go bardzo niedawno. Czuję pomogę sobie zbyt umieszczając to w dół ) podano, że zna wersję rekurencyjną.

Każde wywołanie funkcji w wersji rekurencyjnej dąży do odwiedzenia węzeł związany z wywołaniem funkcji. Funkcja jest kodowany tak, że aktywacja ramka odpowiadająca węzła jest zapisywany na układ stosu (obszar stosu tego procesu) przed Czy to robić swoje główne zadanie, czyli odwiedzić węzeł. Dzieje się tak dlatego, że chcemy odwiedzić lewe poddrzewo węzła Zanim odwiedzicie samego węzła.

Po lewej poddrzewo jest odwiedzana, powrót do ramy naszych zapisanych wyników węzła w środowisku językowym popping samo z wewnętrznego stosu i wizyta naszego węzła jest obecnie niedozwolone.

Mamy naśladować to popychanie i popping z wyraźną stosie.

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

Najlepszym sposobem, aby zrozumieć to, aby narysować funkcjonowania wewnętrznego stosu na papierze na każdym połączeniu i zwrotu wersji rekurencyjnej.

Odpowiedział 24/05/2011 o 15:31
źródło użytkownik

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