What is logic to construct a binary tree? - c++

Question

I have a while loop which continuously takes integers until -1 is entered. Those elements must be inserted into a binary tree (not a BST). If it was a BST, we have a condition for where to insert the new node. But how can I construct a binary tree?
I mean if nodes are 1,2,3,4,5,6..., then
1 is the root, 2 and 3 are the left and right children of node 1,
4 and 5 are the left and right children of node 2, and 6 is left child of node 3, like this:
if(root==NULL)
root= newnode;
else{
if (root->left==NULL)
root->left= insert(root->left,element);
else
root->right= insert(root->right,element);
}
return root;
How do I create a tree like this?

Answer 1

One simple way of doing this is use level order traversal.
Whenever you find a node whose left or right child is NULL, attach the new node as a child of that node; if both left and right are NULL, attach as left child, else attach as right child.
tree_node *insert_node_in_tree(tree_node *root, node new_node) {
if(root == NULL)
return new_node;
queue <tree_node * > qu;
tree_node *temp;
qu.push(root);
while(!(qu.empty())) {
temp = qu.front();
qu.pop();
if(temp->left == NULL || temp->right == NULL)
break;
qu.push(temp->left);
qu.push(temp->right);
}
if(temp->left == NULL)
temp->left = new_node;
else
temp->right = new_node;
return root;
}

Answer 2

The algorithm outlined by WhozCraig in his comment can be realized by the code:
/* Create a binary tree with nodes presented in BFS order */
#include <cassert>
#include <iostream>
#include <vector>
#include <iomanip>
using std::vector;
using std::cout;
using std::cin;
using std::ostream;
using std::setw;
struct node
{
int data;
node *left;
node *right;
node(int n) : data(n), left(0), right(0) { }
};
void print_bt(const node *root);
int main()
{
vector<node> v;
int n;
// Read data to EOF or a negative value
while (cin >> n && n >= 0)
v.push_back(node(n));
// Create binary tree
for (size_t i = 0; i < v.size()/2; i++)
{
assert(2*i+1 < v.size());
v[i].left = &v[2*i+1];
if (2*i+2 < v.size())
v[i].right = &v[2*i+2];
}
// Print binary tree
print_bt(&v[0]);
return 0;
}
// print_bt() presents the data so that if you mentally rotate the
// output through 90º clockwise (so the root is at the top), then the
// left child appears on the left and the right on the right. Reversing
// the order of left/right leaves that as somewhat confusing.
void print_bt(const node *root)
{
static int level = 0;
if (root != nullptr)
{
level++;
print_bt(root->right);
cout << setw(4*level) << root->data << '\n';
print_bt(root->left);
level--;
}
}
For example, given the numbers 1 to 6 as input, it produces:
3
6
1
5
2
4
and given the numbers 1 to 15 as input, it produces:
15
7
14
3
13
6
12
1
11
5
10
2
9
4
8
It helps if you visualize the tree rotated 90º clockwise, so that the 1 is at the top.