Où peut-on utiliser « Cette » méthode dans Recursion

Question

J'ai une méthode dans une classe statique qui essaie de convertir un arbre binaire à une liste

J'aimerais faire récursive, mais je ne pouvais pas

J'ai implémenté d'autres méthodes dans ma classe comme add(), delete(), find().

Voici le code

class ARB 
{ 
     private: 
       struct BT 
       { 
         int data; 
         BT *l; 
         BT *r; 
       }; 
       struct BT *p; 
     public 
       ARB(); 
       ~ARB(); 
       void del(int n); 
       void add(int n); 
}; 

    void ARB::del(int num) 
{ 
//The code ,don't care about it 

    }; 

main() 
{ 
// 
    BTR T; 
    T.add(3); 
    T.add(5); 

}; 

Voici ce que nous devons faire pour transférer le code d'arbre binaire à la liste.

LLC ARB::changeit() 
{ LLC x; 
     while(this!=NULL) 
     { 
      x.add(this->data); // 
       if(this.l==NULL) 
       { 
         x.print(); //To print the elemnts of List 
         return(x); 
       } 
       else 
       { 
         x=changeit(this.l); 
       } 

       if(this.r!=NULL) 
       { 
         x.~LLC(); 
         x=changeit(this.r); 
         return(x); 
       } 

     } 

} 

Answer 1

La description du problème est difficile à suivre, mais je remarquai que vous avez utilisé les mots-clés this et static, qui sont généralement mutuellement exclusifs.

Toute fonction static appartient à une classe et non à un objet. Les fonctions statiques peuvent être appelées en utilisant la syntaxe ARB::myStaticFunction() et ne nécessitent pas d'objet réel ARB. Donc, this à l'intérieur d'une telle fonction ne fait référence à aucun objet et n'a aucun sens.

Answer 2

Cet appel n'a pas de sens:

x=changeit(this.l); 

Depuis this fait référence à l'objet ARB qui n'a pas membre appelé l. La même chose vaut pour ce code:

this->data 

Vous faites parfois this.data et parfois this->data vous semblez si confondre sur la notion d'un pointeur d'objet. Votre ARB a le BT* appelé p qui est censé être la racine de l'arbre. Vous devriez commencer à partir de cela.

Aussi c'est obviosly mal:

x.~LLC(); 

Ne pas appeler le destructeur de LLC explicitement!

L'algorithme général pour placer récursive un arbre binaire dans une liste (pseudo-code):

tolist(node, list): 
    if node == NULL: 
    return 
    else: 
    tolist(node.left, list) 
    list.append_to_end(node.data) 
    tolist(node.right) 

Cela suppose append_to_end de la liste est efficace, de donner un sens (ce qui est réalisable avec un pointeur de fin dans la liste) . En outre, il prend une liste comme argument et la modifie. Vous pouvez facilement le modifier pour avoir une méthode récursive interne qui le fait et une méthode externe qui crée une liste, appelle cette méthode et retourne la liste.