Binary Tre Rotasjon

Jeg jobber med å implementere en AVL Søk treet. Så langt jeg er ferdig koding del og jeg har begynt å teste den for feil. Jeg fant ut at mine node rotasjon metoder er avlyttet og for Guds skyld jeg kan ikke forstå hva som er problemet.

Algoritmen fungerer som det skal på papiret, men når utført på en maskin det godt ... lekker tre noder.

Dette er den metode som benyttes for å rotere en node til venstre: http://pastebin.com/mPHj29Af

bool avl_search_tree::avl_tree_node::rotate_left()
{
    if (_right_child != NULL) {
        avl_tree_node *new_root = _right_child;
 
        if (_parent != NULL) {
            if (_parent->_left_child == this) {
                _parent->_left_child = new_root;
            } else {
                _parent->_right_child = new_root;
            }
        }
 
        new_root->_parent = _parent;
        _parent = new_root;
 
        _right_child = new_root->_left_child;
        new_root->_left_child = this;
 
        if (_right_child != NULL) {
            _right_child->_parent = this;
        }
 
        //update heights
        update_height();
        new_root->update_height();
 
        return true;
    }
 
    return false;
}

I min innsetting metoden kommen jeg AVL balansere del og i stedet jeg prøver bare å rotere nyinnsatte noden til venstre. Resultatet for å sette inn hele tall i stigende rekkefølge: min treet bare inneholder den opprinnelige rot (første noden er satt inn) og alle andre noder er lekket.

Alle hjelpe med å identifisere problemet er høyt verdsatt som jeg begynner å bli gal.

For ordens skyld: hvis jeg ikke bruker noen rotasjoner treet ikke vil lekke noder og det fungerer som en vanlig ubalansert binært søketre (for innsetting og oppslag).

Edit: På grunn av AJG85 kommentar vil jeg legge observasjonene:

Jeg har lagt printf 'sjekker' for å destructor metoden for avl_search_tree :: avl_tree_node som vil skrive ut nøkkelverdien (i mitt tilfelle 32 bits heltall) før opprydding og til innsatsen metoden i avl_search_tree som skal skrive ut nøkkelen bare satt inn.

Så i programmets Entrypoint jeg tildele en avl_search_tree på haugen og legge nøklene til det i stigende rekkefølge og deretter slette den.

Med AVL Balancing aktivert får jeg følgende resultat i terminalen:

bool avl_search_tree::insert(const int&) : 1
bool avl_search_tree::insert(const int&) : 2
bool avl_search_tree::insert(const int&) : 3
bool avl_search_tree::insert(const int&) : 4
bool avl_search_tree::insert(const int&) : 5
bool avl_search_tree::insert(const int&) : 6
bool avl_search_tree::insert(const int&) : 7
bool avl_search_tree::insert(const int&) : 8
avl_search_tree::avl_tree_node::~avl_tree_node() : 1

Hvilket betyr thatall innsett var vellykket, men bare roten har blitt slettet.

Med AVL Avbalanseringen kommentert ut det fungerer som en vanlig binært søketre. Terminalen utgang er:

bool avl_search_tree::insert(const int&) : 1
bool avl_search_tree::insert(const int&) : 2
bool avl_search_tree::insert(const int&) : 3
bool avl_search_tree::insert(const int&) : 4
bool avl_search_tree::insert(const int&) : 5
bool avl_search_tree::insert(const int&) : 6
bool avl_search_tree::insert(const int&) : 7
bool avl_search_tree::insert(const int&) : 8
avl_search_tree::avl_tree_node::~avl_tree_node() : 1
avl_search_tree::avl_tree_node::~avl_tree_node() : 2
avl_search_tree::avl_tree_node::~avl_tree_node() : 3
avl_search_tree::avl_tree_node::~avl_tree_node() : 4
avl_search_tree::avl_tree_node::~avl_tree_node() : 5
avl_search_tree::avl_tree_node::~avl_tree_node() : 6
avl_search_tree::avl_tree_node::~avl_tree_node() : 7
avl_search_tree::avl_tree_node::~avl_tree_node() : 8

Hvilket betyr at alt er skikkelig rengjort.

Nå ... hvordan har jeg kommet til den konklusjon at rotasjons metoder er problemene? Under kommen AVL balansering subrutine jeg lagt til en linje som roterer hver nyinnsatte node til venstre. Resultatet? Det samme som om AVL Balancing subrutine ble aktivert.

Og om update_height () -metoden, betyr det ikke endrer treets struktur på noen måte.

Jeg håper dette vil avklare det.

Edit 2:

For å klargjøre noen flere ting, er hans hvordan avl_tree_node destructor er gjennomført:

avl_search_tree::avl_tree_node::~avl_tree_node()
{
    printf(%s : %d\n, __PRETTY_FUNCTION__, *_key);

    if (_left_child != NULL) {
        delete _left_child;
    }

    if (_right_child != NULL) {
        delete _right_child;
    }

    if (_key != NULL) {
        delete _key;
    }
}

_left_child og _right_child er pekere til avl_tree_node gjenstander tildelt på haugen.

Edit 3:

Takket være AGJ85 sin andre kommentaren jeg fant problemet. I mine roter metoder glemte jeg at jeg faktisk må oppdatere treets rot peker til den nye rot når roten ble flyttet.

I utgangspunktet treets rot ble alltid peker til den første noden innsatt og uten å oppdatere pekeren når det er nødvendig, ville mine rotere metoder lekke den nye treets rot som faktisk ble konfigurert til høyre. :)

Takk AGJ85!