Hoe werkt een insert soort voor een serie BST werken?

Question

Hoe werkt een insert soort voor een serie BST werken?

stemmen

1

Ik heb geprobeerd om het te doen recursively..The ouder integer varaible zou doen is zoals ik, die voldoen aan de formule 2*i +1voor leftChild's en 2*i +2voor de rechter.

void BST::insert(const data &aData)
{
    if ( items[Parent].empty ) 
    {
        items[Parent].theData = aData;
        items[Parent].empty = false;
    }
    else if ( aData < items[Parent].theData )
    {
        Parent = 2 * Parent + 1;
        if ( Parent >= maxSize ) this->reallocate();
        this->insert(aData);
    }
    else
    {
        Parent = (2 * rightChild++)+ 2;
        if ( Parent >= maxSize ) this->reallocate();
        this->insert(aData);
    }
}

Het werkt prima bij het plaatsen van voorwerpen die kleiner zijn dan de oorspronkelijke ouder zijn ... Maar als ik iets te vinden dat groter is het allemaal omhoog schroeven: x

void BST::reallocate()
{
    item *new_array = new item[maxSize*2];

    for ( int array_index = 0; array_index < maxSize; array_index++ ) 
    {
        if ( ! items[array_index].empty )
        {
            new_array[array_index].theData = items[array_index].theData;
        }
    }
    maxSize *= 2;
    delete [] items;

    items = NULL;
    items = new_array;
}

Hier is mijn Hector dus niemand krijgt meer in de war dan ik ben:

BST::BST(int capacity) : items(new item[capacity]), size(0), Parent(0),
leftChild(0), rightChild(0)
{
    items->empty = true;
    maxSize = capacity;
}
private:
    int size;  // size of the ever growing/expanding tree :)
    int Parent;
    int maxSize;    
    int leftChild;
    int rightChild;
    struct item
    {
        bool empty;
        data theData;
    };
    item *items;    // The tree array

Het inbrengen bovenstaande functie is eigenlijk het beste wat ik kan krijgen ..

                                 R
                                / \
                               /   \
                              /     \
                             L       X
                            / \     / \
                           J   V   K   T   <--The only out of place node.
                          / \   \
                         / NULL  \
                        G        /
                                P

Bij het invoegen van: R, L, J, G, X, K, V, P, Tin die volgorde

c++binary-search-tree

De vraag is gesteld op 18/11/2009 om 01:44
bron van user user40120

In andere talen...

1 antwoorden

sdtom · Answer 1 · 2009-11-24 01:08

Ik vermoed dat je probleem is op deze lijn:

    Parent = (2 * rightChild++)+ 2;

Waarom gebruikt u rightChild hier in plaats van (2 * Parent) + 2?

Voor alle duidelijkheid zijn, kunt u een aantal eenvoudige inline functies om uw klasse toe te voegen voor het berekenen van de indexen van de links / rechts kinderen en de ouder, krijgen een index:

inline int getLeftChildIndex(int nodeNdx) { return (nodeNdx * 2) + 1; }
inline int getRightChildIndex(int nodeNdx) { ... }
inline int getParentIndex(int nodeNdx) { ... }

U kunt ook overwegen gebruik te maken van de klassen search()of find()methode (Ik neem aan dat er is) om te bepalen waar een nieuw knooppunt te voegen. De zoekfunctie moet ofwel de terugkeer van de index van een bestaand knooppunt (het is aan jou om te beslissen hoe het inbrengen van dubbele waarden te behandelen) of de index van de plaats waar de nieuwe waarde moet worden ingevoegd.