How to add node to binary tree in C? - c

Question

How do I add more nodes to my binary tree if A (left) and B (right) are already full? I just need to create a tree that is balanced. But I can't figure out how to add more data to the tree. Any help would be greatly appreciated.
Thanks in advance for any tipps.
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
struct node
{
char *titel;
struct node *A;
struct node *B;
};
void display(struct node *leaf)
{
if (leaf != NULL)
{
display(leaf->A);
printf("%s\n",leaf->titel);
display(leaf->B);
}
}
struct node *insert(char* titel, struct node **leaf)
{
if (*leaf == 0)
{
*leaf = (struct node*)malloc(sizeof(struct node));
(*leaf)->titel = malloc(strlen(titel)+1);
strcpy((*leaf)->titel,titel);
(*leaf)->A = NULL;
(*leaf)->B = NULL;
}
else if ((*leaf)->A == NULL)
{
(*leaf)->A = insert(titel,&(*leaf)->A);
}
else if ((*leaf)->B == NULL )
{
(*leaf)->B = insert(titel,&(*leaf)->B);
}
//WHAT TO ADD HERE TO CREATE ANOTHER NODE?
return(*leaf);
}
int main(int argc, char const *argv[])
{
struct node *root = NULL;
insert("root",&root);
insert("chapter_1A",&root);
insert("chapter_1B",&root);
insert("chapter_2A",&root);
insert("chapter_2B",&root);
insert("chapter_3A",&root);
display(root);
return 0;
}
Output should be like a balanced binary tree. Mustn't be printed but stored like that in memory.
Actual output:
chapter_1A
root
chapter_1B
root
/ \
chapter_1A chapter_1B
/ \ / \
ch_2A ch_2B ch_3A ch_3B
and so on.

Answer 1

How do I add more nodes to my binary tree if A (left) and B (right) are already full?
By "full" I take it that you mean both child nodes themselves have two children. In this case, any new node must be added to one of the children of the children. Typically you would do this via a recursive function, so that it correctly handles the case when the children's children are also "full", and so on.
I just need to create a tree that is balanced
(Note that "balanced" can itself mean several things. For instance, there are "height balanced" and "weight balanced" trees. You don't specify which you want).
The question then is which (full) child to add a new node to - right or left? One option is to keep a count of the total descendants of each node, and always add to the child which has the fewest.
Another option is to keep count of the total number of nodes in the tree, and use the bits in that number (ignoring the first 1 bit) to decide on where to insert the new node. For example, if you have a tree with 5 nodes:
A
B C
D E
To add a new node, increment the node count to 6, which is 110 in binary. Ignore the first 1; interpret the next 1 as "go right" (which takes you to C) and the following 0 as "go left" (which tells you to insert as the left child of C). Your code becomes something like this:
void insert(char* titel, struct node **leaf, int nodeCount, int bitPos)
{
if (*leaf == 0)
{
*leaf = (struct node*)malloc(sizeof(struct node));
(*leaf)->titel = malloc(strlen(titel)+1);
strcpy((*leaf)->titel,titel);
(*leaf)->A = NULL;
(*leaf)->B = NULL;
}
else
{
int currentBit = (nodeCount >> bitPos) & 1;
if (currentBit == 0) {
// insert to left
insert(titel, &((*leaf)->A), nodeCount, bitPos - 1);
}
else
{
// insert to right
insert(titel, &((*leaf)->B), nodeCount, bitPos - 1);
}
}
}
Notice I changed the return type to void since you don't need to return a value. I'll leave the calculation of the initial bitPos value as an exercise (remember: it's the position of the highest order 1 bit, minus 1).
If you also need to remove elements from the tree, you will need to find a way to re-balance it, however.
Note that there are several data structures and algorithms for maintaining balanced trees which support both insertion and deletion. See red-black trees and AVL trees for example. These are usually used for ordered trees, but it should be trivial to adapt them for an unordered-but-balanced tree.