使用指针将节点插入二叉树

Question

I'm trying to create a method for inserting nodes into a BST with the following structs:

// node structure
struct Node {
    int val;
    struct Node* left;
    struct Node* right;
};

// binary tree structure
struct BinaryTree {
    struct Node* root;
};

Originally I created this method for adding nodes to the tree:

// add value to binary tree
void _AddNode(struct Node* node, int val) {
    if (node == NULL)
        *(&node) = CreateNode(val);
    else if (val <= node->val)
        _AddNode(node->left, val);
    else
        _AddNode(node->right, val);
}
void AddNode(struct BinaryTree* tree, int val) {
    _AddNode(tree->root, val);
}

Using this function to construct the tree, I get a Segmentation fault: 11 error when I try to traverse, print, access data from the tree.

However, when I modified the function to pass in a double pointer and effectively do the same thing it worked:

// add value to binary tree
void _AddNode(struct Node** node, int val) {
    if (*node == NULL)
        *node = CreateNode(val);
    else if (val <= (*node)->val)
        _AddNode(&(*node)->left, val);
    else
        _AddNode(&(*node)->right, val);
}
void AddNode(struct BinaryTree* tree, int val) {
    _AddNode(&tree->root, val);
}

Why does the latter work, but the former doesn't.

Answer 1

However, when I modified the function to pass in a double pointer and effectively do the same thing it worked

Substantially the same thing, on fundamentally different data . The (&node) in your original attempt gives you a pointer to a local variable . When you dereference that and assign to the result, you are therefore modifying the local variable. Such a modification is not visible in any way to the caller.

On the other hand if you pass (say) a suitable double pointer to your function, say _AddNode(&(*node)->left, 42) , then the value of the function parameter points to the same thing: the (*node)->left of the caller. If you dereference that pointer and assign to the result then naturally that is visible to the caller.

It seems that both the original and modified function are identical

Clearly, they are not lexically identical. You seem to mean that they appear to you to be equivalent , but since the difference in behavior disproves such an equivalence, it stands to reason that the manifest differences in the two functions in fact produce different semantics. The key thing that seems to have confused you is that in C, function arguments are always passed by value , so each function parameter starts with the value passed by the caller, but is not an alias for the caller's corresponding argument. Parameters of pointer type are no exception.