Löschen des gesamten Baum binäre Suche auf einmal

Question

Löschen des gesamten Baum binäre Suche auf einmal

stimmen

-1

Ich habe versucht, die Lösch BST-Funktion zu implementieren, aber ich weiß nicht, warum es nicht funktioniert, ich denke, es ist logisch richtig. Kann jede Stelle mir bitte sagen, warum ich Laufzeitfehler immer und wie soll ich es korrigieren.

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

Alle anderen Funktionen arbeiten korrekt, Sie müssen nur die überprüfen delete_treeFunktion, die anderen Code bereitgestellt , um die Vorstellung von der Struktur meiner BST zu geben.

c++binary-search-tree

Veröffentlicht am 09/11/2011 um 09:22
quelle vom benutzer Zohaib

In anderen Sprachen...

7 antworten

stimmen

0

Sie sollten nicht von der Wurzel lesen , nachdem sie zu löschen. Bewegen Sie die delete(root)Zeile nach unten.

Beantwortet am 09/11/2011 um 09:26
quelle vom benutzer David Grayson

stimmen

1

Das Problem ist hier:

 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;

Sie versuchen, NULL zu einem Mitglied der Wurzel zuweisen:

root->left=NULL;

die bereits gelöscht wurde. Es gibt keine Notwendigkeit, das zu tun, da Sie befreien bereits den Speicherdelete_tree(root->left);

Beantwortet am 09/11/2011 um 09:28
quelle vom benutzer Luchian Grigore

stimmen

0

löschen rekursiv linken und rechten Unterbaum und Ihrem Baum wird so einfach wie gelöscht werden:

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

Beantwortet am 15/07/2014 um 18:12
quelle vom benutzer kalimba

stimmen

1

Sie können löschen: // Diese Funktion der Reinigung ist:

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

// Das ist, wo wir die Reinigungsfunktion aufrufen:

cleantree(a);
a=NULL;

// Wo „a“ Zeiger auf Wurzel des Baumes.

Beantwortet am 24/01/2015 um 06:39
quelle vom benutzer Turdubek Joldoshov

stimmen

0

Kurze Antwort: Ihre Implementierung des Knotendeskriptors die korrekte explizite destructor Umsetzung fehlt (der Standard vom Compiler generiert wird durch den Aufruf der Delete-Operator verwendet werden: Aufruf destructor und die Freigabe der zugewiesenen Platz auf dem Heap) -Der ein, dass klare Verweise auf die Geschwister

Beantwortet am 05/06/2016 um 00:39
quelle vom benutzer damirlj

stimmen

-1

hier ist mein Vorschlag mit Rekursivität ..

 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
}

Beantwortet am 06/02/2017 um 17:28
quelle vom benutzer Brahim KHOUY

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

In Ihrem 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;
    }
}

Sie Zugriff auf Root - Variable , nachdem Sie es gelöscht haben

Auch Sie rufen

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

pre_display nach Baum löschen. delete_tree nach dem Baum zu löschen sollte auch die BST.head auf NULL gesetzt

Auch eine Kritik. BST ist vom Typ Baum. Es ist bereits eine Kopfelementvariable, die den Wurzelknoten. So delete_tree / pre_display brauchen keine Parameter überhaupt.