Cancellare l'intero albero binario di ricerca in una sola volta

Question

Cancellare l'intero albero binario di ricerca in una sola volta

voti

-1

Ho cercato di implementare la funzione di eliminazione BST, ma non so il motivo per cui non funziona, penso che sia logicamente corretto. Qualsiasi organismo può dirmi, perché sto ottenendo l'errore fase di esecuzione e come devo correggerlo.

  #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;
}

Tutte le altre funzioni funzionano correttamente, non vi resta che verificare il delete_treefunzionamento, l'altro codice viene fornito per dare l'idea della struttura del mio BST.

c++binary-search-tree

È pubblicato 09/11/2011 alle 09:22
fonte dall'utente Zohaib

In altre lingue...

7 risposte

voti

0

Non si dovrebbe leggere dalla radice dopo l'eliminazione di esso. Spostare la delete(root)linea verso il basso.

Risposto il 09/11/2011 a 09:26
fonte dall'utente David Grayson

voti

1

Il problema è qui:

 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;

Si sta tentando di assegnare NULL a un membro di root:

root->left=NULL;

che è già stato eliminato. Non c'è bisogno di farlo in quanto si sta già liberando la memoria indelete_tree(root->left);

Risposto il 09/11/2011 a 09:28
fonte dall'utente Luchian Grigore

voti

0

Ricorsivamente eliminare sinistra e destra di sottostruttura e il vostro albero sarà cancellato il più semplice:

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

Risposto il 15/07/2014 a 18:12
fonte dall'utente kalimba

voti

1

È possibile eliminare da: // Questa è la funzione di pulizia:

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

// Questo è dove noi chiamiamo la funzione di pulizia:

cleantree(a);
a=NULL;

// dove "a" è puntatore alla radice dell'albero.

Risposto il 24/01/2015 a 06:39
fonte dall'utente Turdubek Joldoshov

voti

0

Risposta breve: l'implementazione del descrittore nodo manca l'attuazione distruttore esplicito corretta (il default generato dal compilatore sarà utilizzato chiamando l'operatore delete: chiamando distruttore e rilasciando lo spazio allocato sul heap) -la uno che chiari riferimenti al fratelli

Risposto il 05/06/2016 a 00:39
fonte dall'utente damirlj

voti

-1

ecco il mio suggerimento usando ricorsività ..

 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
}

Risposto il 06/02/2017 a 17:28
fonte dall'utente Brahim KHOUY

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

Nella tua 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;
    }
}

si accede radice variabile dopo averlo eliminato

Inoltre si chiama

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

pre_display dopo l'eliminazione di albero. delete_tree dopo l'eliminazione l'albero dovrebbe anche impostare il BST.head NULL

Anche una critica. BST è di tipo albero. Ha già una variabile membro testa indica il nodo radice. Così delete_tree / pre_display non hanno bisogno di alcun parametro a tutti.