Having issues with Binary Tree node counting

Question

When calling Node Counting function in public I get incompatible declaration and in private my returns do not match the function and I cannot call in the test driver.

Float, int, void, bool(stupid I know).

CPP

void BinaryTree::count(TreeNode* root) {
if(root == NULL)
    return 0;
else 
    if(root->left == NULL && root->right == NULL)
        return 1;
    else
        return count(root->left) + count(root->right) + 1;    
}

Header (I think I need to make this public so I can call in the test driver but I was only able to declare in the CPP from Private.)

void count(TreeNode *);

Driver

cout << "Total Number of Nodes " << endl;
tree.count();
cout << endl;

In the Driver test CPP tree.count is inaccessible which is understandable because its being called from private, but as a public call the declaration is incompatible.

Answer 1

void BinaryTree::count(TreeNode* root) {
  if(root == NULL)
   return 0;
  else 
   if(root->left == NULL && root->right == NULL)
       return 1;
   else
       return count(root->left) + count(root->right) + 1;    
}

that operation return an int (at least a number) , it must have a signature returning a number, for instance

int BinaryTree::count(TreeNode* root) 

your definition is also complicated for nothing, can be

 int BinaryTree::count(TreeNode* root) {
   return (root == NULL)
     ? 0
     : count(root->left) + count(root->right) + 1;    
 }

and because it does not modify the instance make it const

 int BinaryTree::count(TreeNode* root) const {
   return (root == NULL)
     ? 0
     : count(root->left) + count(root->right) + 1;    
 }

Having

tree.count();

without arg and visibly writing the count you need an other operation like

void BinaryTree::count() const {
  cout << count(..the tree node..);
}

that operation must be public, probably the previous one is private

Anyway it is better to not write the count but to return it, letting the caller doing what it wants with.

So finally something like :

// I use a _struct because fields accessible by BinaryTree
// but  may be a class and BinaryTree is a friend class etc
struct TreeNode {
  // ...
  TreeNode * left;
  TreeNode * right;
  // ...
};

class BinaryTree {
  public:
    // ...
    int count() const { return count(tree); }
    // ...
  private:
    // ...
    int count(TreeNode *) const;
    // ...
    TreeNode * tree;
    // ...
};

int BinaryTree::count(TreeNode* root) const {
   return (root == NULL)
     ? 0
     : count(root->left) + count(root->right) + 1;    
 }

and somewhere cout << "Total Number of Nodes " << tree.count() << endl;