La suppression à la fois l'ensemble de l'arbre de recherche binaire

Question

La suppression à la fois l'ensemble de l'arbre de recherche binaire

voix

-1

Je suis en train de mettre en œuvre la fonction de suppression de BST mais je ne sais pas pourquoi il ne fonctionne pas, je pense qu'il est logiquement correct. Tout organisme peut me dire s'il vous plaît, pourquoi je reçois une erreur de temps d'exécution et comment dois-je corriger.

  #include <iostream>
  using namespace std;

class node{
public:
int data;
node *right;
node *left;
node(){
    data=0;
    right=NULL;
    left=NULL;
      }
};

class tree{
node *head;
int maxheight;
     public:
tree(){head=0;maxheight=-1;}
bool deletenode(int key,node* root);
int get_height(){return maxheight;}
void insert(int key);
void pre_display(node* root);
     void delete_tree(node *root);
     node* get_head(){return head;}
         };

void tree::insert(int key){
     node *current=head;
    node *newnode=new node;

    if(newnode==NULL)
    throw(key);

    newnode->data=key;
    int height=0;

if(head==0){
head=newnode;
     }
else
{
    while(1){
    if(current->right==NULL && current->data < newnode->data)
    {
        current->right=newnode;
        height++;
        break;
    }
    else if(current->left==NULL && current->data > newnode->data)
    {
        current->left=newnode;
        height++;
        break;
    }
    else if(current->right!=NULL && current->data < newnode->data)
    {
         current=current->right;
         height++;
   }
    else if(current->left!=NULL && current->data > newnode->data)
    {
               current=current->left;
          height++;
    }
         }
 }
 if(height>maxheight)
 maxheight=height;
 }

 void tree::pre_display(node *root){
 if(root!=NULL)
 {
 cout<<root->data<< ;
 pre_display(root->left);
 pre_display(root->right);
 }
 }

 void tree::delete_tree(node *root){
  if(root!=NULL)
 {
 delete_tree(root->left);
 delete_tree(root->right);
 delete(root);
 if(root->left!=NULL)
 root->left=NULL;
 if(root->right!=NULL)
 root->right=NULL;
 root=NULL;
 }
 }

int main(){
tree BST;
int arr[9]={17,9,23,5,11,21,27,20,22},i=0;

for(i=0;i<9;i++)
BST.insert(arr[i]);

BST.pre_display(BST.get_head());
cout<<endl;
BST.delete_tree(BST.get_head());
BST.pre_display(BST.get_head());
cout<<endl;

system(pause);
return 0;
}

Toutes les autres fonctions fonctionnent correctement, il vous suffit de vérifier la delete_treefonction, l'autre code est fourni pour donner l'idée de la structure de mon BST.

c++binary-search-tree

Créé 09/11/2011 à 09:22
source utilisateur Zohaib

Dans d'autres langues...

7 réponses

voix

0

Vous ne devriez pas lire racine après l' avoir supprimé. Déplacer la delete(root)ligne vers le bas.

Créé 09/11/2011 à 09:26
source utilisateur David Grayson

voix

1

Le problème est ici:

 delete_tree(root->left);
 delete_tree(root->right);
 delete(root);
 if(root->left!=NULL)
 root->left=NULL;
 if(root->right!=NULL)
 root->right=NULL;
 root=NULL;

Vous essayez d'attribuer NULL à un membre de la racine:

root->left=NULL;

qui a déjà été supprimé. Il n'y a pas besoin de faire cela puisque vous libérant déjà la mémoiredelete_tree(root->left);

Créé 09/11/2011 à 09:28
source utilisateur Luchian Grigore

voix

0

supprimer récursive arbre sous gauche et à droite et votre arbre sera supprimé aussi simple que:

void delete(node *root){
  if(root->left==NULL && root->right==NULL)  //leaf node, delete it!!
    free(root);
  delete(root->left);
  delete(root->right);
 }

Créé 15/07/2014 à 18:12
source utilisateur kalimba

voix

1

Vous pouvez supprimer par: // Ceci est fonction de nettoyage:

void cleantree(tree *root){
 if(root->left!=NULL)cleantree(root->left);
 if(root->right!=NULL)cleantree(root->right);
 delete root;}

// C'est là que nous appelons la fonction de nettoyage:

cleantree(a);
a=NULL;

// Où « un » est pointeur à la racine de l'arbre.

Créé 24/01/2015 à 06:39
source utilisateur Turdubek Joldoshov

voix

0

Réponse courte: implémentation du descripteur de noeud manquant la mise en œuvre de destructor correcte explicite (la valeur par défaut généré par le compilateur sera utilisé en appelant l'opérateur delete: appeler destructor et de libérer l'espace alloué sur le tas) -Celle qui références claires à la frères et sœurs

Créé 05/06/2016 à 00:39
source utilisateur damirlj

voix

-1

voici ma suggestion en utilisant récursivité ..

 template <class T> void Tree<T>::destroy(Noeud<T> ** r){

            if(*r){
                if(!(*r)->left && !(*r)->right){  //a node having no child
                  delete *r; *r=NULL;
                }else if((*r)->left && (*r)->right){ //a node having two childs
                    destroy(&(*r)->left); //destroy the left tree
                    destroy(&(*r)->right); //destroy the right tree
                    destroy(r); //destroy the node
                }else if((*r)->left){ //a node has only left child
                    destroy(&(*r)->left); //destroy the left tree
                    destroy(r); //destroy the node
                }else if((*r)->right){ //a node has only right child
                    destroy(&(*r)->right); //destroy the right tree
                    destroy(r); //destroy the node
                }
            }
}

//in function main()
int main(){
Tree<int> a(5); // 'a' is a tree of int type with a root value equal 5
a.add(2);a.add(7);a.add(6);a.add(-1);a.add(10); // insert values into the tree 
a.destroy(&a.root);  //destroy the tree
}

Créé 06/02/2017 à 17:28
source utilisateur Brahim KHOUY

parapura rajkumar · Accepted Answer · 2011-11-09 09:27

Dans votre delete_tree

void tree::delete_tree(node *root){
    if(root!=NULL)
    {
        delete_tree(root->left);
        delete_tree(root->right);
        delete(root);
        if(root->left!=NULL)
            root->left=NULL;
        if(root->right!=NULL)
            root->right=NULL;
        root=NULL;
    }
}

vous accédez à la racine variable après avoir supprimé

Aussi, vous appelez

    BST.delete_tree(BST.get_head());
BST.pre_display(BST.get_head());

pre_display après la suppression de l' arbre. delete_tree après la suppression de l'arbre doit également définir le BST.head NULL

Aussi une critique. BST est de type arbre. Il a déjà une variable d'élément de tête indiquant le noeud racine. Alors delete_tree / pre_display ne pas besoin de paramètres du tout.