Copie arbre binaire dans l'ordre

Le code que j'ai écrit jusqu'à présent est:

void copyInOrder(TNode *orgTree, Tnode *& copyTree){
    if(orgTree !=NULL){
        copyInOrder(orgTree->left_link);
        //create leftmost node of tree but how to link to parent
        copyInOrder(orgTree->right_link);
    }
}

Je ne sais pas comment le lien à la mère de noeuds comme son afinde.

InformationsquelleAutor Takafu Keyomama | 2010-10-12
  1. 3

    Je pense que ce serait quelque chose comme cela.

    void copyInOrder(TNode *orgTree, Tnode *& copyTree){
    if(orgTree !=NULL){
        //left side
        TNode newLeftNode = cloneNode(orgTree->left_link);
        copyTree->left_link = newLeftNode;
        copyInOrder(orgTree->left_link, copyTree->left_link);

        //right side
        TNode newRightNode = cloneNode(orgTree->right_link);
        copyTree->right_link = newRightNode;
        copyInOrder(orgTree->right_link, copyTree->right_link);
    }
}
    • où est la définition de cloneNode?
    • Je n'ai pas l'écrire, mais ce serait une méthode qui a créé un nouveau nœud sur la base des données à partir d'un autre.
    InformationsquelleAutor Alpha
  2. 3

    Supposons que orgTree points à la racine (2). Pour la copie, nous devons faire ce qui suit:

    Copie arbre binaire dans l'ordre

    1. créer un nœud à copyTree, et la copie de la valeur 2 dans il
    2. si orgTree->left != NULL, appel copyInOrder( orgTree->left, copyTree->left );
    3. si orgTree->right != NULL, appel copyInOrder( orgTree->right, copyTree->right );

    BTW, ce type de parcours est connu comme pré-commande traversal, dans l'ordre de la traversée à l'est différent.

    InformationsquelleAutor Arun
  3. 3
    tnode *copy(tnode *root) {
     tnode *new_root;
     if(root!=NULL){
         new_root=new tnode;
         new_root->data=root->data;
         new_root->lchild=copy(root->lchild);
         new_root->rchild=copy(root->rchild);
     } else return NULL;
     return new_root;
 }
    InformationsquelleAutor mohammad ghamgosar
  4. 0

    C'est une méthode récursive qui fonctionne et qui est simple

    Tnode* CopyInOrder(Tnode* root){
    if(root == NULL){return NULL;}
    else{
        Tnode* temp = new Tnode;
        temp -> data = root -> data;
        temp -> left = copyInOrder(root -> left);
        temp -> right = copyInOrder(root -> right);
        return temp;
        }
}
    InformationsquelleAutor Zosoh