बीएसटी

Question

का रिकर्सिव सम्मिलन मैंने लूप का उपयोग करके बीएसटी में सम्मिलन के लिए एक फ़ंक्शन बनाया है और यह पूरी तरह से ठीक काम कर रहा है। अब, जब मैं पुनरावृत्ति का उपयोग करके इसे करने के लिए लिख रहा हूं, मुझे नहीं पता कि यह ठीक से काम क्यों नहीं कर रहा है, हालांकि तर्क मेरे अनुसार सही है। ऐसा लगता है कि सम्मिलन समारोह से बाहर आने के बाद बीएसटी पेड़ में कोई नया नोड जोड़ा जा रहा है और पेड़ का सिर फिर से नल हो रहा है।

#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; 
    void delete_tree(node *root); 
public: 
    tree(){head=0;maxheight=-1;} 
    void pre_display(node* root); 
    node* get_head(){return head;} 
    void insert(int key,node* current); 
}; 

void tree::insert(int key,node *current){ 
    if(current==NULL) 
    { 
     node *newnode=new node; 
     newnode->data=key; 
     current=newnode; 
    } 
    else{ 
     if(key<current->data) 
     insert(key,current->left); 
     else 
     insert(key,current->right); 
    } 
    return; 
} 

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

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.get_head()); 

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

    system("pause"); 
    return 0; 
} 

कृपया मुझे बताएं कि इसे काम करने के लिए एल्गोरिदम में मुझे क्या बदलना चाहिए।

Answer 1

अपने डालने में समारोह

void tree::insert(int key,node *current){ 
    if(current==NULL) 
    { 
     node *newnode=new node; 
     newnode->data=key; 
     current=newnode; 
    } 
    else{ 
     if(key<current->data) 
      insert(key,current->left); 
     else 
      insert(key,current->right); 
    } 
    return; 
} 

आप नव आवंटित सिर के लिए एक नए नोड लेकिन कभी सेट BST :: सिर का आवंटन। तो बीएसटी :: get_head हमेशा शून्य वापस आ जाएगा।

इसे ठीक करने का एक तरीका एक नोड वापस करने के लिए सम्मिलित होगा। यह आपके मामले में रूट नोड होगा और बीएसटी :: हेड को इस मान पर सेट करेगा।

Answer 2

आपका रिकर्सन ठीक दिखता है, लेकिन आप वास्तव में नोड कहीं भी जोड़ें! आप बस पेड़ के माध्यम से recurs।

संपादित आप इस तरह, एक सूचक के लिए सूचक ले जाने की insert विधि बदल सकते हैं:

void tree::insert(int key, node **current) 
{ 
    if(*current == NULL) 
    { 
     node *newnode = new node; 
     newnode->data = key; 
     *current = newnode; 
    } 
    else 
    { 
     if(key < (*current)->data) 
      insert(key, &(*current)->left); 
     else 
      insert(key, &(*current)->right); 
    } 
} 

और मुख्य में इसे इस तरह कहते हैं:

BST.insert(arr[i], &BST.get_head()); // Note the ampersand (&) 

Answer 3

आप इस प्रयास करना चाहिए

   node tree:: insert (int key , node * current) { 

        if (! current) { 
          node * newnode = new node ; 
          newnode -> key = key; 
          current = newnode ; 
         } 
        else if (key < current -> key) { 
         current -> left = insert (key , current ->left 
         } 
        else 
         current -> right = insert (key , current->right) 
       return current ; 
       } 

यह ठीक काम करता है .... jsut हर बार जब कोई नया नोड डाला जाता है तो हेड नोड अपडेट करें और यह अद्यतन वर्तमान नोड वापस कर देगा।

Answer 4

बस के रूप में

void tree::insert(int key,node*& current){ 
    if(current==NULL) 
    { 
    node *newnode=new node; 
    newnode->data=key; 
    current=newnode; 
    } 
    else{ 
    if(key<current->data) 
     insert(key,current->left); 
    else 
     insert(key,current->right); 
    } 
    return; 
} 

अपने कार्य को बदलने के लिए एक संदर्भ पैरामीटर के रूप में अपने इनपुट सूचक हैं।

Answer 5

struct node{ 
    node* left; 
    node* right; 
    int data; 
}; 

node* root=NULL; 

node* create(node* head,int val){ 
    if(head==NULL){ 
     node* nn=new node; 
     nn->data=val; 
     nn->left=NULL; 
     nn->right=NULL; 
     head=nn; 
    } 
    else if(val<head->data) 
     head->left=create(head->left,val); 
    else if(val>head->data) 
     head->right=create(head->right,val); 
    return head; 
} 

int main(){ 
    int num=0; 
    cout<<"Enter value in tree or press -1 to Exit\n"; 
    while(num!=-1){ 
     cin>>num; 
     if(num==-1){ 
      cout<<"\nTree Created\n"; 
      break; 
     } 
     else{ 
      root=create(root,num); 
     } 
    } 
} 

आशा इस कोड को मुख्य रूप से आपकी समस्या