bir kerede tüm ikili arama ağacı silme

Question

bir kerede tüm ikili arama ağacı silme

oy

-1

Ben silme BST işlevi uygulamak çalışıyorlar ama neden çalışmadığını, bunun mantıksal olarak doğru olduğunu düşünüyorum bilmiyorum. Ben çalışma zamanı hata alıyorum neden herhangi beden, lütfen bana ve nasıl düzeltmek gerekir.

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

Diğer tüm fonksiyonlar sadece kontrol etmeniz gerekir, düzgün çalıştığından delete_treefonksiyonu, diğer kod benim BST yapısı fikir vermek için sağlanmıştır.

c++binary-search-tree

Oluştur 09/11/2011 saat 09:22
kaynak kullanıcı Zohaib

Diğer dillerde...

7 cevaplar

oy

0

Sildikten sonra kökünden okumamalı. Taşı delete(root)aşağı çizgi.

Cevap 09/11/2011 saat 09:26
kaynak kullanıcı David Grayson

oy

1

Sorun buradadır:

 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;

Sen kökü bir üyesi NULL atamak için çalışıyoruz:

root->left=NULL;

hangi zaten silindi. Zaten bellek içinde azat ettiğin beri bunu yapmaya gerek yokdelete_tree(root->left);

Cevap 09/11/2011 saat 09:28
kaynak kullanıcı Luchian Grigore

oy

0

Yinelemeli sol ve sağ alt ağacını silmek ve ağaç basit olduğu kadar silinecektir:

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

Cevap 15/07/2014 saat 18:12
kaynak kullanıcı kalimba

oy

1

Sen tarafından silebilirsiniz: Bu temizlik fonksiyonudur //:

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

Biz temizlik işlevi çağırmak nerede // budur:

cleantree(a);
a=NULL;

// Nerede "a" ağacın köküne göstericidir.

Cevap 24/01/2015 saat 06:39
kaynak kullanıcı Turdubek Joldoshov

oy

0

Kısa cevap: Doğru açık yıkıcı uygulanmasını eksik düğüm tanımlayıcısı uygulamanız (derleyici tarafından oluşturulan varsayılan delete operatörünü arayarak kullanılacaktır: yıkıcı çağırmasını ve öbek üzerinde tahsis edilen alanı bırakmadan) -the biri olduğu açık referanslar kardeşler

Cevap 05/06/2016 saat 00:39
kaynak kullanıcı damirlj

oy

-1

Burada recursivity kullanarak benim öneri ..

 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
}

Cevap 06/02/2017 saat 17:28
kaynak kullanıcı Brahim KHOUY

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

senin delete_tree olarak

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

Eğer erişen kök sildikten sonra değişkeni

Ayrıca çağrı

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

ağaç sildikten sonra pre_display. delete_tree ağacını sildikten sonra da NULL BST.head belirlesin

Ayrıca eleştiri. BST tipi ağacının olduğunu. Zaten kök düğümünü belirten bir kafa üye değişkeni vardır. Yani delete_tree / pre_display hiç bir parametre gerekmez.