Binary search tree print() only printing out first 2 nodes

[darego]

I have a simple Binary Search Tree which contains various chars. I need a function which prints out all of the node char values in ascending order. Although my current function only prints out the first 2 char nodes. Can anyone see why?

  //TreeNode.h
struct TreeNode
{
	char value;
	TreeNode* left, * right;
	TreeNode(char theValue);
};

//TreeNode.cpp
TreeNode::TreeNode(char theValue) : value(theValue), left(nullptr), right(nullptr)
{
}


//BinaryTree.h
class BinaryTree
{
public:
	BinaryTree();
	void add(char data);
	void findFullNode();

private:
	static void add(TreeNode* toAdd, char data);
	TreeNode* rootPtr;
	void findFullNode(TreeNode* root);
};

//BinaryTree.cpp

BinaryTree::BinaryTree() : rootPtr(nullptr)
{
}

void BinaryTree::add(char data)
{
	if (rootPtr)
	{
		add(rootPtr, data);
	}
	else
	{
		rootPtr = new TreeNode(data);
	}
}


void BinaryTree::add(TreeNode* toAdd, char data)
{
	if (data < toAdd->value) {
		if (toAdd->left)
		{
			add(toAdd->left, data);
		}
		else
		{
			toAdd->left = new TreeNode(data);
		}
	}
	else {
		if (toAdd->right) {
			add(toAdd->right, data);
		}
		else {
			toAdd->right = new TreeNode(data);
		}
	}

}

void BinaryTree::findFullNode()
{
	findFullNode(rootPtr);
}

void BinaryTree::findFullNode(TreeNode* root)
{
	if (root)
	{
		findFullNode(root->left);
		if (root->left && root->right)
			std::cout << root->value << " ";
		findFullNode(root->right);
	}
}

//Main.cpp
int main()
{
	BinaryTree tree;

	tree.add('c');
	tree.add('h');
	tree.add('z');
	tree.add('b');
	tree.add('d');
	tree.add('e');

	tree.findFullNode();

	return 0;
}

[dutch]

You just need to get rid of the if.
The function name is a little strange.
Maybe just 'print'?
And it should be a static function.

void BinaryTree::findFullNode(TreeNode* root)
{
	if (root)
	{
		findFullNode(root->left);
		std::cout << root->value << " ";
		findFullNode(root->right);
	}
}

[darego]

Thanks as always dutch. I am trying to get the chars printed in ascending order and the above code is printing "b c d e h z". Maybe my tree implementation is incorrect?

[dutch]

But that is ascending, isn't it?

[darego]

Ignore that post lol. Thanks again for the help! :)

[dutch]

No problem. :)
It can be handy to get a sense of the actual tree structure.
The tree_print function that I added is a simple way to do that.
Just turn your head sideways and it basically looks like a tree.

b c d e h z 
        z
    h
            e
        d
c
    b

Also note that member functions that don't modify the object should be declared const.
(Static functions are never const since they aren't implicitly passed the object.)

#include <iostream>
#include <iomanip>

// TreeNode.h
struct TreeNode
{
    char value;
    TreeNode *left, *right;
    TreeNode(char theValue);
};

// TreeNode.cpp
TreeNode::TreeNode(char theValue) : value(theValue), left(nullptr), right(nullptr)
{
}

// BinaryTree.h
class BinaryTree
{
public:
    BinaryTree();
    void add(char data);
    void print() const;
    void print_tree() const;

private:
    static void add(TreeNode* toAdd, char data);
    static void print(TreeNode* node);
    static void print_tree(TreeNode* node, int indent=0);

    TreeNode* rootPtr;
};

// BinaryTree.cpp

BinaryTree::BinaryTree() : rootPtr(nullptr)
{
}

void BinaryTree::add(char data)
{
    if (rootPtr)
    {
        add(rootPtr, data);
    }
    else
    {
        rootPtr = new TreeNode(data);
    }
}

void BinaryTree::add(TreeNode* toAdd, char data)
{
    if (data < toAdd->value) {
        if (toAdd->left)
        {
            add(toAdd->left, data);
        }
        else
        {
            toAdd->left = new TreeNode(data);
        }
    }
    else {
        if (toAdd->right) {
            add(toAdd->right, data);
        }
        else {
            toAdd->right = new TreeNode(data);
        }
    }

}

void BinaryTree::print() const
{
    print(rootPtr);
    std::cout << '\n';
}

void BinaryTree::print(TreeNode* node)
{
    if (node)
    {
        print(node->left);
        std::cout << node->value << ' ';
        print(node->right);
    }
}

void BinaryTree::print_tree() const
{
    print_tree(rootPtr);
    std::cout << '\n';
}

void BinaryTree::print_tree(TreeNode* node, int indent)
{
    if (node)
    {
        print_tree(node->right, indent + 1);
        std::cout << std::setw(indent*4) << "" << node->value << '\n';
        print_tree(node->left, indent + 1);
    }
}

// Main.cpp
int main()
{
    BinaryTree tree;

    for (char ch: {'c', 'h', 'z', 'b', 'd', 'e'})
        tree.add(ch);

    tree.print();

    tree.print_tree();

    return 0;
}

[darego]

great stuff, thanks. Out of curiosity, does it make a difference where you put const in the function definition? I have recently seen fuctions with various consts in the same function declaration

[darego]

also, am i correct to say that the print_tree() function uses an In-order traversal? and not Pre-order or Post-order?

[dutch]

For this usage of const (that the entire object is const so that the member function can't modify it) it needs to be where I put it. Other uses are to put it in front of individual inputs to a function. So for instance I probably should've also put it in the following places for the static functions (the entire functions can't be const, but the inputs can be):

class BinaryTree
{
    // ...
    static void print(const TreeNode* node);
    static void print_tree(const TreeNode* node, int indent=0);
    // ...
};

// ...

void BinaryTree::print(const TreeNode* node)
{
    if (node)
    {
        print(node->left);
        std::cout << node->value << ' ';
        print(node->right);
    }
}

void BinaryTree::print_tree(const TreeNode* node, int indent)
{
    if (node)
    {
        print_tree(node->right, indent + 1);
        std::cout << std::setw(indent*4) << "" << node->value << '\n';
        print_tree(node->left, indent + 1);
    }
}

[darego]

Thanks a lot dutch. Works perfect now