Is that usage of tree a waste of memory? - c

Question

In learning C, I pay more attention to memory allocation and we were basically given this code in my Uni building a binary tree.
Each time in the for loop a pointer will be created and only then we will assign the addresses of each subtree and its children to the nodes. But with that we have created over 10 pointers right?
Could we juste have a pointer and keep updating it? Like the implementation with recursion where the main pointer get only updated and then returned.
typedef struct tr {
int data;
struct tr *left, *right;
} btree, *btreeptr;
btree *createtree(int data) {
btree *newtree;
newtree = (btree *)malloc(sizeof(btree));
newtree->left = NULL;
newtree->right = NULL;
newtree->data = data;// Is the same as : (*p).data,
return newtree;
}
int main() {
btree *test[10];
btreeptr baum;
int i;
for (i = 0; i < 10; i++) {
test[i] = createtree(i);
}
baum = test[0];
test[0]->left = test[1];
test[0]->right = test[2];
test[1]->left = test[3];
test[1]->right = test[4];
test[2]->right = test[5];
test[4]->left = test[6];
test[5]->left = test[7];
test[5]->right = test[8];
test[7]->left = test[9];
printf("Size: %d\n", size(baum));
printf("Leaves: %d\n", numberOfLeaves(baum));
printf("Height: %d\n", height(baum));
return 0;
}
Please if my understanding of memory is wrong I would appreciate being corrected.

Answer 1

It probably would have been better to ask your teacher why they chose to do that; I can only guess. My guess is that they want you to write the functions called by the three printf statements at the end, none of which depend on the values stored in the tree nodes. I'm pretty sure that later one, you will be writing functions to insert and delete nodes in the tree, at which point the temporary vector of allocations will disappear. For now, however, there must be some mechanism for creating the tree edges for at least one test tree. And how are you going to verify that your implementations of size, height and numberOfLeaves, work if you don't have some tree to try them with?
Your instructor is probably trying to teach you something quite important: when you are writing a system, you should test everything, as soon as possible (before you write hundreds of lines of code using untested functions), and as far as possible without dependencies on other untested functions. "Mocking" a test tree is one technique for testing without depending on the tree insert function (which hasn't yet been written).
Eventually, the data fields will be important. For now, storing the node number as the value of the data field might help you during debugging, since it will let you see which node is being processed at any point in time. Learning to debug is also a very important skill. So you might eventually decide to thank whoever designed that course material.

Answer 2

Title: Is that usage of tree a waste of memory?
It's good to question what comes your way.
If the purpose of the example was to introduce the data structure known as a binary tree (with arbitrary connections), then the example serves its purpose. Is such a binary tree an economic solution given the values and connections presented? Perhaps not...
For your interest:
#include <stdio.h>
typedef struct tr {
int data;
struct tr *left, *right;
};
int main( void ) {
unsigned char t[ 10 ] = { 0x12, 0x34, 0x05, 0x00, 0x60, 0x78, 0x00, 0x90 };
for( size_t i = 0; i < sizeof t; i++ )
printf( "node %d: left %d right %d\n", i, t[i]>>4, t[i]&0xF );
printf( "size of t[] = %ld\n", sizeof t );
printf( "size of 10x struct tr = %ld\n", 10 * sizeof( struct tr ) );
return 0;
}
node 0: left 1 right 2
node 1: left 3 right 4
node 2: left 0 right 5
node 3: left 0 right 0
node 4: left 6 right 0
node 5: left 7 right 8
node 6: left 0 right 0
node 7: left 9 right 0
node 8: left 0 right 0
node 9: left 0 right 0
size of t[] = 10
size of 10x struct tr = 120
(And, my ancient compiler uses 4 byte pointers, not 8 byte pointers.)
The "payload" in the example is limited to binary values 0 through 9, so one 'nybble' (4 bits) fulfills the shown requirements.
Some may argue that the initialisation shown above requires too much effort.
Below is initialisation that corresponds to the OP version.
unsigned char t[ 10 ] = { 0 };
t[0] = 1 << 4 | 2;
t[1] = 3 << 4 | 4;
t[2] = 0 << 4 | 5;
t[4] = 6 << 4 | 0;
t[5] = 7 << 4 | 8;
t[7] = 9 << 4 | 0;
Perhaps someone will re-write these statements using a simple macro.

Answer 3

Is it a waste of memory? Well, in a sense. The code lays out a bunch of stuff into a binary tree of pointers but doesn't do anything with them. This code could eventually be utilized for something, which is probably why it's being shown to you.
Another interesting thing is that this code unintentionally forms a Heap, a subset of binary tree that can be represented with a contiguous array, in which the children of any node with index i are simply the entries i*2+1 and i*2+2. That style of binary tree requires no pointers simply because all the structural relationships are implied by the nodes' positions. Though because Heaps also have other requirements and benefits, this code would not represent a heap if, say, the values in the initial array were random instead of sequential.
Likewise most binary trees cannot be represented as a contiguous array. For those, this may indeed be the most efficient representation. It also has the benefit of being really easy to handle recursively.