Question

I am trying to remove the left child (10) of a sample binary search tree using two methods:

• Method1: By passing pointer to a pointer to the current node.
• Method2: By passing address of the pointer to the current node. This does not removes the node, but calling delete corrupts the pointer arrangement, causing a crash while printing the nodes.

The tree looks like this and I am trying to delete 10 and replace it with 5

       20
       |  
   10--|---30
    |
5---|

I have some understanding of pointers. But still, I am not clear with this behavior of pointers.

#include <iostream>
class Node
{
public:
    Node(int key) : leftChild(0), rightChild(0), m_key (key){}
    ~Node(){}

    Node *leftChild;
    Node *rightChild;
    int m_key;
};

Node* build1234(int, int, int, int);
void print(Node *);
void print1234(Node *);

void removeLeft(Node **nodePtr)
{
    Node *oldPtr = *nodePtr;
    if(*nodePtr)
    {
        *nodePtr = (*nodePtr)->leftChild;
        delete oldPtr;
    }
}

int main()
{
    Node *demo1 = build1234(10, 20, 30, 5);
    Node *demo2 = build1234(10, 20, 30, 5);
    print1234(demo1);
    print1234(demo2);

    //Method1 - 10 is correctly removed with 5
    Node **nodePtr = &demo1;
    nodePtr = &(*nodePtr)->leftChild;
    removeLeft(nodePtr);
    print1234(demo1);

    //Method2 - 10 is not removed
    Node *node = demo2;
    node = node->leftChild;
    removeLeft(&node);
    print1234(demo2);       
    return 0;
}

Node* build1234(int B, int A, int C, int D)
{
    Node *root = new Node(A);
    root->leftChild = new Node(B);
    root->rightChild = new Node(C);
    root->leftChild->leftChild = new Node(D);
    return root;
}
void print(Node *node)
{
    if(node)
    {
        print(node->leftChild);
        std::cout << "[" << node->m_key << "]";
        print(node->rightChild);
    }
}

void print1234(Node *node)
{
    std::cout << std::endl;
    print(node);
}

Note: This question is not about BST, but pointers. If you see the two calls to removeLeft(nodePtr) and the removeLeft(&node) in the main() function.

1. How are these two different?
2. Why the second method fails to achieve the desired result?

Answer 1

In the first case, you are passing an address of a pointer that exists in the tree, so you are modifying the contents of the tree directly.

In the second case, you are passing an address of a variable that is local to main() instead. The tree is not modified, and deleting from the address is accessing stack memory, which is why it crashes