Binary Search Tree wissen (Inorder Pred methode) C ++

Question

Binary Search Tree wissen (Inorder Pred methode) C ++

stemmen

1

Ok, dus ik dacht dat het was opgelost, maar ik krijg helemaal inconsistente resultaten. Ik herschreef het vriendelijk van vanaf nul vers te beginnen en hier zijn mijn resultaten. Ik krijg geen fouten, geen crashen, het gewoon niet ze te verwijderen. Het is gewoon helemaal verknoeit de boom en geeft me een ton meer bladeren, en mengt alles op. Niet zeker waar anders te gaan

template <class T>
void BST<T>::remove(struct Node<T>*& root, const T& x)
{
   Node<T>* ptr = root;
   bool found = false;
   Node<T>* parent;


   while (ptr != NULL && !found)
   {
       if (x < ptr->data)
       {
           parent = ptr;
           ptr = ptr->left;
       }
       else if (x > ptr->data)
       {
           parent = ptr;
           ptr = ptr->right;
       }
       else
           found = true;
   }

   if (found == false)
       return;
   else
   {
       if(ptr->left != NULL && ptr->right != NULL)
       {
           Node<T>* inOrderPtr = ptr->left;
           parent = ptr;
           while (inOrderPtr->right != NULL)
           {
               parent = inOrderPtr;
               inOrderPtr = inOrderPtr->right;
           }

           ptr->data = inOrderPtr->data;
           ptr = inOrderPtr;
       }
    Node<T>* subPtr = ptr->left;
    if (subPtr == NULL)
        subPtr = ptr->right;

    else if (parent->left == ptr)
        parent->left = subPtr;

    else
        parent->right = subPtr;

    delete ptr;
    }

c++binary-search-tree

De vraag is gesteld op 29/10/2008 om 05:56
bron van user Doug

In andere talen...

3 antwoorden

stemmen

0

Je moet niet bellen remove()recursief in het derde geval (waar je "niet zeker of dit juist is" commentaar is). In het geval dat de het knooppunt te verwijderen en heeft twee kinderen, wat je wilt doen is het vinden van de meest rechtse kind van de linker kind (zoals je doet, de resulterende knooppunt wordt opgeslagen in parent). Dit knooppunt heeft geen recht kind - maken het zo dat het recht kind is de juiste kind van het knooppunt te worden verwijderd. Dan verander gewoon de rootvariabele links daarvan kind te zijn; Geen behoefte om de verandering datalid in ieder knooppunten of te bellen removerecursief.

In afbeeldingen:

Voor:
         r <- wortel points here
       / \
      / \
     ab
    / \ / \
   xcyy
      / \
     xd
        /
       X

Na:
      a <- wortel punten hier
     / \
    xc
       / \
      xd
         / \
        xb
           / \
          yy

antwoordde op 29/10/2008 om 06:22
bron van user Adam Rosenfield

stemmen

1

Wat er werkelijk gebeurde is dat macht zoekopdrachten werden omgekeerd, zodat het zou eigenlijk gewoon doorgaan recht, maar die gegevens zijn niet echt correct matching en dus het zou een muur lijkt te raken.

if (root->data < x)
        remove(root->left, x);
    else 
        remove(root->right, x);

zou moeten zijn

if(x < root->data)
remove(root->left, x);
else
remove(root->right, x);

antwoordde op 29/10/2008 om 08:09
bron van user Doug

Greg Rogers · Accepted Answer · 2008-10-29 06:57

Elk T gevonden in de boom uniek? Het lijkt erop dat ze zijn van uw code ...

Het lijkt erop dat dit zou moeten werken:

In het andere geval verwijderen het hoofdknooppunt:

Node<T> *tmp_r = root->left;
Node<T> *parent = root;
while (tmp_r->right != NULL)
{
    parent = tmp_r;
    tmp_r = tmp_r->right;
}
Node<T> *tmp_l = tmp_r;
while (tmp_l->left != NULL)
    tmp_l = tmp_l->left;

tmp_l->left = root->left;
tmp_r->right = root->right;
parent->right = NULL;

parent = root;
root = tmp_r;
delete parent;