CareerCup

def recur_clone(tree):         
    def __recur_clone(root):  
        if not root:
            return None 
        node = BT._Node(root.val)
        node.left = __recur_clone(root.left)
        node.right = __recur_clone(root.right)
        return node
    ct = BT()
    ct.root = __recur_clone(tree.root)    
    return ct

Node {
public string Value{get;set}
public Node Left {get;set;}
public Node Right{get;set;}
}


Node CloneNode(Node n1)
{

if(n1 != null)
{
Node c = new Node{
Value = n1.Value
};
c.Left = CloneNode(n1.Left);
c.Right = CloneNode(n1.Right);
}
}

Cloning with recursion is trivial. Was it asked to be done without recursion ?

node  *clone( root ) 
{
   if (root == NULL ) : return root;
 
   //create new node and make it a copy of node pointed by root
   node *temp = (node *)malloc(sizeof(node)) ;
   temp->data = root-> data;    //copying data
   temp->left = clone(root -> left);    //cloning left child
   temp->right = clone(root -> right);  //cloning right child
   return temp;
}

struct Node
{
    Node* left;
    Node* right;
    int   val;
};

Node* clone(const Node* node)
{
    Node* new_node = nullptr;
    
    if(node)
    {
        new_node = new Node { nullptr, nullptr, node->val };
        
        new_node->left  = clone(node->left);
        new_node->right = clone(node->right);
    }
    
    return new_node;
}