Binary Rechercher Arbre Suppression (méthode Inorder Pred) C ++

voix
1

Ok, donc je pensais que c'était fixé, mais je suis tout à fait d'obtenir des résultats incohérents. Je réécrite genre de partir de zéro pour prendre un nouveau départ et voici mes résultats. Je reçois aucune erreur, ne se écraser, il ne vient pas les supprimer. Il a juste salit totalement l'arbre et me donne une tonne plus de feuilles, et mélange tout. Je ne sais pas où aller

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;
    }
Créé 29/10/2008 à 05:56
source utilisateur
Dans d'autres langues...                            


3 réponses

voix
0

Vous ne devriez pas appellerez remove()récursive dans le troisième cas (où votre « ne sais pas si cela est juste » commentaire est). Dans le cas où le nœud d'enlever a deux enfants, ce que vous voulez faire est de trouver le plus à droite enfant de l'enfant gauche (comme vous le faites, le noeud résultant est stocké dans parent). Ce nœud n'a pas d' enfant droit - faire en sorte que son enfant est le droit à l'enfant le droit du nœud à supprimer. Ensuite , il suffit de changer la rootvariable à son enfant gauche; pas besoin de changer le datamembre des noeuds ou appeler removerécursive.

En images:

Avant:
         r <- points de racines ici
       / \
      / \
     un B
    / \ / \
   xcyy
      / \
     xd
        /
       X

Après:
      un <- points de racines ici
     / \
    xc
       / \
      xd
         / \
        XB
           / \
          yy
Créé 29/10/2008 à 06:22
source utilisateur

voix
0

Est-ce que chaque T trouve dans l'arbre unique? On dirait qu'ils sont de votre code ...

On dirait que cela devrait fonctionner:

Dans le cas d'autre suppression du nœud racine:

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;
Créé 29/10/2008 à 06:57
source utilisateur

voix
1

Qu'est-ce qui se passait vraiment est que les recherches Might ont été inversés il serait en fait juste continuer à droite mais les données n'a pas été il serait vraiment correctement et répondent donc frapper un mur, il semble.

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

aurait du être

if(x < root->data)
remove(root->left, x);
else
remove(root->right, x);
Créé 29/10/2008 à 08:09
source utilisateur

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