Slette hele binært søketre på en gang

Question

Slette hele binært søketre på en gang

stemmer

-1

Jeg har prøvd å implementere slette BST funksjon, men jeg vet ikke hvorfor det ikke fungerer, tror jeg det er logisk riktig. Kan noen kropp fortelle meg hvorfor jeg får kjøretidsfeil og hvordan skal jeg rette det opp.

  #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 de andre funksjonene fungerer som de skal, trenger du bare å sjekke delete_treefunksjonen, er den andre koden for å gi inntrykk av strukturen i min BST.

c++binary-search-tree

Publisert på 09/11/2011 klokken 08:22
kilden bruker Zohaib

På andre språk...

7 svar

stemmer

0

Du bør ikke lese fra rot etter å ha slettet den. Flytt delete(root)linje ned.

Svarte 09/11/2011 kl. 08:26
kilden bruker David Grayson

stemmer

1

Problemet er her:

 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;

Du prøver å tildele NULL til et medlem av rot:

root->left=NULL;

som allerede var slettet. Det er ikke nødvendig å gjøre det, siden du allerede frigjøre minne idelete_tree(root->left);

Svarte 09/11/2011 kl. 08:28
kilden bruker Luchian Grigore

stemmer

0

Rekursivt slette venstre og høyre sub treet og treet vil bli slettet så enkelt som:

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

Svarte 15/07/2014 kl. 17:12
kilden bruker kalimba

stemmer

1

Du kan slette etter: // Dette er funksjonen til rengjøring:

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

// Det er her vi kaller rengjøringsfunksjonen:

cleantree(a);
a=NULL;

// der "a" er en peker til roten av treet.

Svarte 24/01/2015 kl. 06:39
kilden bruker Turdubek Joldoshov

stemmer

0

Kort svar: implementeringen av noden descriptor mangler riktig eksplisitt destructor gjennomføring (standard generert av kompilatoren vil bli brukt ved å ringe slette operatør: ringer destructor og slippe tildelt plass på haugen) -den som klare referanser til søsken

Svarte 05/06/2016 kl. 00:39
kilden bruker damirlj

stemmer

-1

her er mitt forslag å bruke recursivity ..

 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
}

Svarte 06/02/2017 kl. 17:28
kilden bruker Brahim KHOUY

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

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

du har tilgang root variabel etter at du har slettet den

Også du ringe

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

pre_display etter å ha slettet treet. delete_tree etter å ha slettet treet bør også sette BST.head til NULL

Også en kritikk. BST er av type tre. Den har allerede en hodedel variabel som indikerer rotnoden. Så delete_tree / pre_display ikke trenger noen parametre i det hele tatt.