C++ Binary Tree Path finding - c++

Question

I have a question regarding finding sum of a path of a binary int tree. This is for college so the requirements are as follows:
Take your code from Lab Sheet 3B (Binary Tree) for a binary tree of integers, and code a
method called hasPathSum() which given a binary tree and a sum, return true if the tree
has a root-to-leaf path such that adding up all the values along the path equals the given
sum. Return false if no such path can be found. The function prototype is
int hasPathSum(struct node* node, int sum)
Note: a "root-to-leaf path" is a sequence of nodes in a tree starting with the root node
and proceeding downward to a leaf (a node with no children). An empty tree contains
no root-to-leaf paths. So for example, the following tree has exactly four root-to-leaf
paths:
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
Root-to-leaf paths:
path 1: 5 4 11 7
path 2: 5 4 11 2
path 3: 5 8 13
path 4: 5 8 4 1
For this problem, we will be concerned with the sum of the values of such a path -- for
example, the sum of the values on the 5-4-11-7 path is 5 + 4 + 11 + 7 = 27.
I am having trouble with this. I have a binary tree, but the function hasPathSum() requirs to pass a node, not a tree. I canot figure out how to do this. I also don't know how to find the sum of a path from root to leaf (the hasPathSum body as well). This needs to be done recursively.
Any help is greatly appreciated.
Here is my node class:
#include <stdio.h>
#pragma once
struct TreeNode
{
public:
friend class BinaryTree;
TreeNode(int theData) : data(theData) {}
bool isLeaf();
private:
int data;
TreeNode *leftlink;
TreeNode *rightLink;
};
Here is the BinaryTree header file:
#include "TreeNode.h"
#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
#pragma once
class BinaryTree
{
public:
BinaryTree();
void add(int toadd);
int height();
void inorderShow() const;
int hasPathSum(TreeNode * tree, int sum);
private:
void add(TreeNode *toAdd, TreeNode *& addHere);
int height(TreeNode *& root);
TreeNode *root;
void inorderShow(TreeNode *subTree) const;
};
And my BinaryTree cpp file:
#include "BinaryTree.h"
BinaryTree::BinaryTree()
{
}
void BinaryTree::add(int toAdd)
{
TreeNode *node = new TreeNode(toAdd);
add(node, root);
}
int BinaryTree::height()
{
return height(root);
}
void BinaryTree::add(TreeNode * toAdd, TreeNode *& addHere)
{
if (addHere == NULL)
addHere = toAdd;
else if (toAdd->data < addHere->data)
add(toAdd, addHere->leftlink);
else //toAdd->data >= addHere->data
add(toAdd, addHere->rightLink);
}
int BinaryTree::height(TreeNode *& n)
{
if (n == NULL)
return -1;
else
return 1 + max(height(n->leftlink), height(n->rightLink));
}
void BinaryTree::inorderShow(TreeNode * subTree) const
{
if (subTree != NULL)
{
inorderShow(subTree->leftlink);
cout << subTree->data << " ";
inorderShow(subTree->rightLink);
}
}
void BinaryTree::inorderShow() const
{
inorderShow(root);
}
int BinaryTree::hasPathSum(TreeNode * tree, int sum)
{
}
In the main.cpp, I have a tree as follows:
#include <iostream>
#include "BinaryTree.h"
#include "TreeNode.h"
using namespace std;
int main()
{
BinaryTree tree;
tree.add(5);
tree.add(6);
tree.add(3);
tree.add(4);
tree.add(9);
tree.add(11);
cout << "Height of the tree is: ";
cout << tree.height() << " ";
cout << "\nIn Order Show:" << endl;
tree.inorderShow();
cout << "Root to leaft path: " << endl;
cout << endl;
system("pause");
return 0;
}
Is someone could explain how can I accomplish this task and meet the requirements (aka not change the function hasPathSum() parameters) I would really appreciate that.

Answer 1

Seems to me the requirement is wrong (or maybe confused)
and code a method called hasPathSum() which given a binary tree and a
sum
So given that this is a method of the binary tree class the tree is passed implicitly so the only explicit parameter is the sum. So the method should be declared as
class BinaryTree
{
...
bool hasPathSum(int sum);
...
};
However the given signature is
int hasPathSum(struct node* node, int sum)
which has the wrong return type (int not bool) and an unexplained node parameter.
Here's how I would organise the solution, since it involves two methods, it maybe explains the confusion.
class BinaryTree
{
...
public:
bool hasPathSum(int sum) { return hasPathSumHelper(root, sum); }
...
private:
static bool hasPathSumHelper(TreeNode* node, int sum);
};
The public hasPathSum method has the signature implied by the problem description (the only signature that makes sense). It simply calls a private method hasPathSumHelper passing the root node and the sum, this gets round the problem of how you pass the private root node.
The hasPathSumHelper method is the recursive routine where the real work is done (left for you to implement). The public hasPathSum just kicks off the calculation by calling this method.
As you think about how to implement the hasPathSumHelper you might find it useful to add additional parameters (a sum_so_far parameter which, as you descend the tree, is the sum of all the nodes above you makes sense to me). That's OK because it's a private method, you can add what you like.