Parsing an uninitialized value into a function - c

Question

I'm trying to write a little program that goes through a list of numbers in an array and just inserts them into a binary search tree. Here's what I have:
#include <stdio.h>
#include <stdlib.h>
typedef struct node_t node_t;
struct node_t {
int data;
node_t *left;
node_t *right;
};
int insert(node_t *node, int n);
int main(void) {
int array[8] = {5, 8, 3, 6, 9, 2, 4, 7};
int i;
node_t *root;
for (i = 0; i < 8; i++) {
insert(root, array[i]);
}
return 0;
}
int insert(node_t *node, int n) {
if (node == NULL) {
node = malloc(sizeof node);
node->data = n;
return 1;
}
if (n > node->data) {
insert(node->left, n);
} else if (n < node->data) {
insert(node->right, n);
} else {
return -1;
}
return 0; // Suppress 'control reaches end of non-void function'
}
when I compile with gcc I get a warning saying "'root' may be used uninitialized in this function". Running it causes on errors (on Windows at least), however, printing out root->data in main() yields a 0.
The idea I was trying to implement was the insert() function checking if the pointer to the input node was NULL so it could then malloc it. Also, due to how the recursion is handled, the number being inserted should be inserted at that node. If the node did NOT equal NULL, then I would recursively call insert() again on the side of the node where the number should be inserted.
I understand the reason why this doesn't work has something to do with the pointer root not being directed anywhere, nor root->left/root->right, however, I don't know what I can do to fix this. Any help would be appreciated, thank you!

Answer 1

There might be more problem with the code you posted but I listed a few problems below.
Since it is the node that you need to allocate memory for if it contains NULL, you need to change this:
if (node->data == NULL) {
To this:
if (node == NULL) {
Also, you need to initiate the root node, since it will just contain whatever happens to be on stack at that moment and it may or may not be NULL (e.i. the thing you want to compare with in insert function). So initiate it like so:
node_t *root = NULL;
Last thing is to change to malloc to calloc function (or do a memset to zero on the memory separately). Otherwise the variables node->left and node->right can contain non NULL values that could result in making use of uninitialized memory.

Answer 2

Your program does indeed pass an unintialized root variable to the insert() function. But even if initialize root you are still going to have problems
because in order to populate the tree, you need to pass pointer to pointer (as you want to be able modify the pointer root in main()). Similarly, you need modify the argument to
the recursive calls to insert() as well.
I notice you don't really use the return value of insert(). So, it can just be a void function. I added some in-code comments to explain some problems.
#include <stdio.h>
#include <stdlib.h>
typedef struct node_t node_t;
struct node_t {
int data;
node_t *left;
node_t *right;
};
void print(node_t *r) { /* In order tree traversal. Gives the sorted output. */
if (!r) return;
print(r->left);
printf("%d ", r->data);
print(r->right);
}
void insert(node_t **node, int n);
int main(void) {
int array[] = {5, 8, 3, 6, 9, 2, 4, 7}; /* Removed the size. It can be calculated using sizeof and helps when array size changes */
int i;
node_t *root = NULL;
/* Without hard-coding, array size can be calculated like this. */
for (i = 0; i < sizeof array/sizeof array[0]; i++) {
insert(&root, array[i]);
}
print(root);
return 0;
}
void insert(node_t **node, int n) {
if (*node == NULL) {
*node = malloc(sizeof *node);
if (*node == NULL) { /* Need to check the return value for failure. */
perror("malloc");
exit(1);
}
(*node)->left = (*node)->right = NULL;
(*node)->data = n;
return;
}
if (n < (*node)->data) /* Insert smaller elements on the left for it to be a binary tree - but not neccessary */
insert(&(*node)->left, n);
else /* Another else below this isn't needed. There can't be any error with the number 'n' itself */
insert(&(*node)->right, n);
}