BST

#include <stdio.h>
#include <stdlib.h>

typedef struct tree_node
{
    int value;
    struct tree_node *left, *right;
} node;

node* binaryTree(int values[], size_t sizeOfTree);
node* searchTree(node* treeNode, int value);
node* findParent(node* treeNode, node* childNode);
void insertNode(node** root, node* treeNode);
void deleteNode(node* treeNode);
void printTree(node* treeNode);

int main()
{
    node *rootNode, *foundNode, *foundParent;
    int values[10] = {10, 8, 9, 4, 3, 11, 45, 89, 43, 100};

    rootNode = binaryTree(values, (sizeof(values)/sizeof(int)));

    if (rootNode)
    {
        printf("\r\nRoot node address: %p \t\t Root node value: %d \r\n\r\n", rootNode, rootNode->value);
        printTree(rootNode);
    }
    else
    {
        printf("Failed to build tree");
        return 1;
    }

    return 0;
}

node* binaryTree(int values[], size_t sizeOfTree)
{
    node *current, *root;
    int i;

    root = NULL;

    for (i = 0; i < sizeOfTree; i++)
    {
        if ((current = (node*)malloc(sizeof(node))) != NULL) // doubt it
        {
            current->left = current->right = NULL;
            current->value = values[i];
            insertNode(&root, current);
        }
        else
        {
            printf("Memory exception.");
            return NULL;
        }
    }

    return root;
}

void insertNode(node** root, node* treeNode)
{
    if (!(*root))
    {
        *root = treeNode;
        return;
    }

    if (treeNode->value < (*root)->value)
        insertNode(&(*root)->left, treeNode);
    else if (treeNode->value > (*root)->value)
        insertNode(&(*root)->right, treeNode);
}

node* searchTree(node* treeNode, int value)
{
    node* current;

    current = NULL;

    if ((value < treeNode->value) && (treeNode->left != NULL)) // make sure the tree actually has a node to search...
        current = searchTree(treeNode->left, value);
    else if (value == treeNode->value)
        current = treeNode;
    else if ((value > treeNode->value) && (treeNode->right != NULL))
        current = searchTree(treeNode->right, value);

    return current;
}

node* findParent(node* treeNode, node* childNode)
{
    node* parent;
    parent = NULL;

    if ((treeNode->left == childNode) || (treeNode->right == childNode))
        parent = treeNode;
    else
    {
        if ((treeNode->left != NULL) && (parent == NULL)) // only continue searching if a result has not been found
            parent = findParent(treeNode->left, childNode);
        if ((treeNode->right != NULL) && (parent == NULL))
            parent = findParent(treeNode->right, childNode);
    }

    return parent;
}

void deleteNode(node* treeNode)
{
    // still to do
}


void printTree(node* treeNode)
{
    if (treeNode->left)
        printTree(treeNode->left);

    printf("Node address: %p \t\t Left node address: %p \t\t Right node address: %p \t\t Node value: %d \r\n", treeNode, treeNode->left, treeNode->right, treeNode->value);

    if (treeNode->right)
        printTree(treeNode->right);
}