头指针不包含二叉树中的子节点

Question

I'm copying a binary tree and I'm having an issue where my root pointer of the new tree ends up only containing the 1st node that is to be copied, and no others. I believe the issue has something to do with the fact that when I pass in the pointers in the recursion in the helper function, for some reason they are not being reassigned to the new nodes memory address. Like in helper(t1->left, t2->left) t2->left never actually ends up becoming the value I intend it to have, it stays null.

   bool first_time = true;
   TreeNode* ref = NULL;
    void helper(TreeNode* t1, TreeNode* t2) {
        if(t1) {
            t2 = new TreeNode(t1->val);
            if(first_time) {
                ref = t2;
                first_time = false;
            }
            helper(t1->left, t2->left);
            helper(t1->right, t2->right);
        }
        
    }
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        TreeNode* tree1 = new TreeNode(1);
        tree1->left = new TreeNode(2);
        tree1->right = new TreeNode(3);
        helper(tree1, NULL);
        return ref;
    }

Answer 1

check your globals first_time and ref .

if (first_time) {
  ref = t2;           // global
  first_time = false; // global set to never go here again
}

It is actually the root of your problem - you change other global variable ref once you pass first node to your function and never change it anywhere afterwards. So, basically, on every recursive call you leak memory with dangling pointers. Probably, you should pass parameter first_time to your function and probably pass ref as parameter as assignable

Answer 2

You have a couple of problems here.

First, ref and first_time are serious flaws and you should avoid writing code with such global state. It is not reentrant, and not thread-safe.

Second, you're trying to write to the t2 pointer and change the caller's pointer to that value. However, you're passing in a copy of t2 so writes to it will be lost.

It doesn't take much to clean it up, just change your function to take a reference to pointer and writes to t2 will persist back to callers. Note, t2 is an "out" parameter, and so the initial caller will get the tree copy returned through this pointer.

Here's a fixed version:

void helper(TreeNode* t1, TreeNode*& t2) {
    if(t1) {
        t2 = new TreeNode(t1->val);
        helper(t1->left, t2->left);
        helper(t1->right, t2->right);
    }  
}

Here's what your test function would look like:

TreeNode* copyTest() {
    TreeNode* tree1 = new TreeNode(1);
    tree1->left = new TreeNode(2);
    tree1->right = new TreeNode(3);
    
    TreeNode* tree2 = nullptr;
    helper(tree1, tree2);  // tree2 is written to as new root.
    return tree2;
}

But out parameters are generally discouraged if they are not needed.

Why not write your copyTree function to return a pointer to the copied tree? Basically get rid of the 2nd argument in, and allocate a copy of the current tree, recursing down, attaching each child copy to the current node parent copy, and return the parent:

TreeNode* copyTree(TreeNode* tree) {
    TreeNode* ret = nullptr;
    if (tree) {
        ret = new TreeNode(tree->val);
        ret->left = copyTree(tree->left);
        ret->right = copyTree(tree->right);
    }
    return ret;
}

This isn't a great approach to protecting against leaks unless you're really careful, but it's good for understanding the recursion and tree structure.