Basic Programming, BinaryTree

So I'm quite familiar with java, but need to bring myself up to speed on c++. I've got this code going, very basic, just starting some basic functions. My question is as to why the two argument insert doesn't update the pointer in the one argument insert. (to the root, specifically)

Code:

Code:

#include <iostream>
using namespace std;

struct node {
	int keyVal;
	node  * left;
	node  * right;
};

class BinarySearchTree {
public:
	BinarySearchTree();
	~BinarySearchTree();

	void insert(int key);

private:
	node * root;

	void insert(int key, node * node);

};

BinarySearchTree::BinarySearchTree() {
	root = NULL;
}

BinarySearchTree::~BinarySearchTree() {

}

void BinarySearchTree::insert(int key) {
	insert(key, root);
	if (root == NULL) {
		cout << "Didn't work.";
	}
}

void BinarySearchTree::insert(int key, node * leaf) {
	if (leaf == NULL) {
		leaf = new node;
		leaf->keyVal = key;
		leaf->left = NULL;
		leaf->right = NULL;
	}
}

int main() {
	BinarySearchTree foo;
	foo.insert(14);
}

Any input is appreciated,
thanks.

Because the pointer is passed by value and will act as a local variable.
Consider using node*& (reference to pointer) or node** (pointer to pointer) instead.

I think I get it, the question is, what's the difference with the binary code on this site:

Code:

void btree::insert(int key, node *leaf)
{
  if(key< leaf->key_value)
  {
    if(leaf->left!=NULL)
     insert(key, leaf->left);
    else
    {
      leaf->left=new node;
      leaf->left->key_value=key;
      leaf->left->left=NULL;    //Sets the left child of the child node to null
      leaf->left->right=NULL;   //Sets the right child of the child node to null
    }  
  }
  else if(key>=leaf->key_value)
  {
    if(leaf->right!=NULL)
      insert(key, leaf->right);
    else
    {
      leaf->right=new node;
      leaf->right->key_value=key;
      leaf->right->left=NULL;  //Sets the left child of the child node to null
      leaf->right->right=NULL; //Sets the right child of the child node to null
    }
  }
}

void btree::insert(int key)
{
  if(root!=NULL)
    insert(key, root);
  else
  {
    root=new node;
    root->key_value=key;
    root->left=NULL;
    root->right=NULL;
  }
}

isn't it doing the same thing there?

Not at all. Things passed into a function cannot be changed, so leaf (in either yours or theirs) can never be changed. You try to change leaf, and fail; they don't try to change leaf. (You can change what is pointed to by leaf, but you cannot change leaf itself.)

I'm not particularly impressed with that piece of code on this site. The else-if could just be an else, and it could be a lot simpler if the creation of the new node was separated from the linking in of it into the tree.

I suggest passing the in parameter as a node**, or simply returning the new node* to be reassigned to the next node up, or the root.

Alternatively, if you need to change the pointer value itself, you could do something like this:

Code:

void foo(tree *&root);

Just my personal preference instead of using pointer-to-pointer syntax...

Originally Posted by MacNilly

Alternatively, if you need to change the pointer value itself, you could do something like this:

Code:

void foo(tree *&root);

Just my personal preference instead of using pointer-to-pointer syntax...

Doh, for some reason I thought this was in the C forum.
Yes of course, use a reference to a pointer in this case.