Pointer arithmetic: huffman tree traversal - c

Question

I am confused in pointer arithmetic, I want to make a tree traversal function, but I am not quite sure about pointer arithmetic to get distant nodes in the tree. It will be a lot more clear when seen in the code, so here it is.
node **root = huffman_tree(probabilities); // I can only return that as a double ptr
Now if I want data from my root node:
printf("%lf", (*root)->data);
If I want data from roots children:
printf("%lf", (*root)->left->data); // or (*root)->right->data
But what if I want to go further in depth search, I dont know how to reach those nodes?
printf("%lf", (*root)->left->left->data); // thats not working
Also, for tree traversal, this is not working: the program crashes.
node **root = huffman_tree(probabailities);
preorder(*root);
void preorder(node *n){
if(n == NULL) return;
printf("%lf", n->data);
preorder(n->left);
preorder(n->right);
}
For the above examples, the program crashes.
Update 1:
It seems like huffman_tree() is indeed returning a tree with corrupted nodes, I must be doing memory allocation for them incorrectly.
The function is passed an array of probabilities, and then obtains steps as it follows:
1) creates nodes with given probabilities (n probabilities --> n new nodes) [works fine]
2) finds the two nodes with lowest probabilities [works fine]
3) creates a new node which is the parent of the two lowest probabilities nodes
4) assign a new node probability equal to the sum of it's children's probabilities
5) repeat from step 2) until there is only one parentless node left
node **huffman_tree(double *probabs){
int num_of_nodes = NUM_OF_SYMBOLS;
int num = NUM_OF_SYMBOLS;
// 1) create nodes for given probabilities
node *leafs = (node*) malloc(num_of_nodes*sizeof(node));
int i;
for(i=0; i<num_of_nodes; i+=1){
node *n = (node *) malloc(sizeof(node));
n->probab = *(probabs + i);
n->symbol = *(SYMBOLS + i);
n->left = NULL;
n->right = NULL;
*(leafs+i) = *n;
//free(n);
}
node **root;
while(num_of_nodes > 1){
// 2) Find the two nodes with lowest probabilities
node *two_mins =(node *)malloc(2*sizeof(node));
two_mins = find_two_mins(leafs, num_of_nodes);
node min_n1 = two_mins[0];
node min_n2 = two_mins[1];
// 3) Create a parent node with probability equals to sum of its children probabilities
// add a parent node to leafs
node *new_node = (node *) malloc(sizeof(node));
new_node->probab = min_n1.probab + min_n2.probab;
new_node->left = &min_n1;
new_node->right = &min_n2;
leafs = add_node(leafs, new_node, num);
num += 1;
leafs = remove_node(leafs, &min_n1, num);
num -= 1;
leafs = remove_node(leafs, &min_n2, num);
num -= 1;
num_of_nodes -= 1;
root = &new_node;
}
return root;
Function add_node() [seems to be working fine]
node *add_node(node *nodes, node *n, int num){
nodes = realloc(nodes, (num+1)*sizeof(node));
nodes[num] = *n;
return nodes;
Function remove_node() [seems to be working fine]
node *remove_node(node *nodes, node *n, int num){
int i;
int index = 0;
for(i=0; i<num; i+=1){
if(nodes_are_equal(nodes[i], *n)) index = i;
}
for(i=index; i<num-1; i+=1){
nodes[i] = nodes[i+1];
}
nodes = realloc(nodes, (num-1)*sizeof(node));
return nodes;
Update 2
I have changed some things in huffman_tree() function.
Function find_two_mins() no longer exists, but it is replaced with two calls of another function find_min(), which finds only one minimum node at a time. Also, this function takes pointer to the dynamically allocated node, and after minimum value is found, returns it back.
node *root;
while(num_of_nodes > 1){
// 2) Find two min nodes
node *min_n1= (node *)malloc(sizeof(node));
node*min_n2= (node *)malloc(sizeof(node));
*min_n1= *find_min(leafs, num, min_n1);
leafs = remove_node(leafs, min_n1, num);
num -= 1;
*min_n2= *find_min(leafs, num, min_n2);
leafs = remove_node(leafs, min_n2, num);
num -= 1;
printf("\nTwo Min Nodes: %lf\t%lf", min_n1->probab, min_n2->probab);
printf("\nSum Of All: %lf", s);
// 3) Create parent node of two min nodes
node *new_node = (node *) malloc(sizeof(node));
new_node->probab= min_n1->probab+ min_n2->probab;
new_node->left = min_n1;
new_node->right = min_n2;
leafs = add_node(leafs, new_node, num);
num += 1;
free(min_n1);
free(min_n2);
num_of_nodes -= 1;
root = new_node;
printf("root=%p\n", root);
printf("*root=%p\n", *root);
}
return root;
And here is the find_min() function:
node *find_min(node *nodes, int num, node *min_node){
double min_probab = nodes[0].probab;
*min_node= nodes[0];
int i;
for(i=0; i<num; i+=1){
if(nodes[i].probab< min_probab){
min_probab = nodes[i].probab;
*min_node = nodes[i];
}
}
return min_node;
It seems like the problem is something about this output:
printf("root=%p\n", root);
printf("*root=%p\n", *root);
Since it outputs "root = 003A17F0" and "*root = 00000000"
Also, I am providing a screenshot of how the program runs, where root values at any point can be seen.

Answer 1

(*root)->left->left->data is the correct way of accessing grand-child nodes, as long as the child is not null, and assuming your node looks something like:
struct node
{
double data;
struct node * left;
struct node * right;
}
Without seeing the full code, it's hard to be sure what's going on here. Your null check in preorder looks good, so I suspect you must be somehow corrupting one of your nodes, and getting an invalid (but non-NULL) pointer in there.
Putting the following immediately after the null check in preorder should make the problem more obvious:
printf("processing node %p", n); fflush(stdout);
printf(" left=%p\n", n->left); fflush(stdout);
printf(" right=%p\n", n->right); fflush(stdout);
You're looking for pointers that don't "look like" the others, particularly just before it crashes.
The most likely causes for problems are within huffman_tree itself. I'd suspect you've got something in there that's taking the address of a node from the stack rather than dynamically allocating it with malloc.
Edit based on additional information supplied in your "answer":
Your problem is probably in your find_two_mins function. The following code
node *two_mins =(node *)malloc(2*sizeof(node));
two_mins = find_two_mins(leafs, num_of_nodes);
node min_n1 = two_mins[0];
node min_n2 = two_mins[1];
is (correctly) dynamically allocating the memory for the nodes, but then you are throwing the pointer to that dynamic memory away and replacing it with the result of find_two_mins.
You've also got some other memory leaks around the place I think (although it's not causing your problem). Within the initial loop,
node *n = (node *) malloc(sizeof(node));
that doesn't get freed. You're copying that struct into the correctly allocated leafs array, so just make that a node n;.
I haven't looked in detail any further than that, so there might be more problems, but let me know where that gets you.