Binary Search Tree C ++ (Ouders)

Question

Binary Search Tree C ++ (Ouders)

stemmen

0

Ik moet alleen een beetje meer hulp op mijn BST. Dit is wat mijn BST ziet er bij het plaatsen van:

R, L, J, G

                      R   --Root at Index 0
                     / \
     L @ Index1     L   NULL
                   / \
     J @ Index3   J   NULL
                 / \
     G @ Index7 G  NULL

Hier is de code dat maakt het gebeuren.

void BST::insert(const data &aData)
{   
    if ( items[Parent].empty ) 
    {
        items[Parent].theData = aData; // insert at leaf.
        items[Parent].empty = false;
        size++;

        return;
    }           
    for ( int i = 0; i <= size; i++ )
    {
        if ( aData < items[Parent].theData )
        {
            if ( items[2*i+1].empty )
            {
            items[2*i+1].theData = aData;
            items[2*i+1].empty = false;
            }
            else 
                           {
            // we must already have a left child to some root.
                                Parent++;  So make the previous data the root???
            if ( items[Parent].empty )
            {
                items[Parent].theData = items[2*i+1].theData;
                items[Parent].empty   = false;
                Parent = (i-1)/2;
            }
                           } 
        }
        else
        { ...// do the same for data greater than but with items[2*i+2] }

Mijn vraag is dat wanneer zou ik nodig om een nieuwe wortel te maken? Wanneer zou ik nodig om een nieuwe wortel te maken? Voor recomparison?

Is deze aanpak correct? Dank u voor degenen die zelfs beide te kijken naar mijn berichten :)

// De constructeur de BST Class en zijn privé-gedeelte.

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

c++binary-search-tree

De vraag is gesteld op 17/11/2009 om 21:59
bron van user user40120

In andere talen...

2 antwoorden

BostonLogan · Answer 1 · 2009-11-17 22:12

stemmen

1

Uw logica (in plaats van fuzzy ik moet zeggen) lijkt niet te kloppen: Wat voor soort "als" sequentie is dat?

if ( items[2*i+1].empty )
{
}
else if (!items[2*i+1].empty)
{
   if ( items[2*i+1].empty )
   {
        // any code here is unreachable
   }
}

antwoordde op 17/11/2009 om 22:12
bron van user BostonLogan

Andrey · Answer 2 · 2009-11-17 22:46

Ik stel voor dat je dit herimplementeren recursief werken. Iets zoals dit:

void BST::insert(const data& aData, int pos) {
    if (items[pos].empty) {
        // insert it here
    }
    else (aData < items[pos].theData) {
        // go to left child
        insert(aData, 2*pos + 1);
    }
    else {
        // go to right child
        insert(aData, 2*pos + 2);
    }
}

Het is niet echt duidelijk wat ouder, leftChild en rightChild doen in je klas, maar dat is een aparte kwestie.