main.c

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

struct node_t
{
    int value;
    int height;

    struct node_t* left;
    struct node_t* right;
};

// insert
// contains
// print

struct node_t* create_node(int value)
{
    struct node_t* new_node = malloc(sizeof(struct node_t));
    new_node->value = value;
    new_node->height = 1;

    new_node->left = NULL;
    new_node->right = NULL;
};

int max(int a, int b)
{
    return a > b ? a : b;
}

int get_node_height(struct node_t* node)
{
    if (node == NULL)
    {
        return 0;
    }

    return node->height;
}

void update_node_height(struct node_t* node)
{
    node->height = 1 + max(get_node_height(node->left), get_node_height(node->right));
}

struct node_t* insert(struct node_t* root, int value)
{
    if (root == NULL)
    {
        return create_node(value);
    }

    if (value > root->value)
    {
        if (root->right == NULL)
        {
            root->right = create_node(value);
        }
        else
        {
            insert(root->right, value);
        }
    }
    else if (value < root->value)
    {
        if (root->left == NULL)
        {
            root->left = create_node(value);
        }
        else
        {
            insert(root->left, value);
        }
    }
    else
    {
        return root;
    }

    update_node_height(root);

    return root;
}

void print_bst_internal(struct node_t* root, int detailed, int level)
{
    if (root == NULL)
    {
        return;
    }

    printf("%d at level %d with height: %d\n", root->value, level, root->height);
    if (detailed)
    {
        if (root->left != NULL)
        {
            printf("%d at level %d has a left child %d\n", root->value, level, root->left->value);
        }
        else
        {
            printf("%d at level %d has no left child\n", root->value, level);
        }
        if (root->right != NULL)
        {
            printf("%d at level %d has a right child %d\n", root->value, level, root->right->value);
        }
        else
        {
            printf("%d at level %d has no right child\n", root->value, level);
        }
    }

    if (root->left != NULL)
    {
        print_bst_internal(root->left, detailed, level + 1);
    }
    if (root->right != NULL)
    {
        print_bst_internal(root->right, detailed, level + 1);
    }
}

void print_bst(struct node_t* root, int detailed)
{
    print_bst_internal(root, detailed, 0);
}

int search(struct node_t* node, int search_value)
{
    if (node == NULL)
    {
        return 0;
    }
    if (node->value == search_value)
    {
        return 1;
    }
    if (search_value > node->value)
    {
        return search(node->right, search_value);
    }
    if (search_value < node->value)
    {
        return search(node->left, search_value);
    }
}

void visit(struct node_t* node)
{
    if (node == NULL)
    {
        return;
    }

    // pre-order visit
    printf(" %d ", node->value);
    visit(node->left);
    visit(node->right);

    // // in-order visit
    // visit(node->left);
    // printf(" %d ", node->value);
    // visit(node->right);
    //
    // // post-order visit
    // visit(node->left);
    // visit(node->right);
    // printf(" %d ", node->value);
}

int main()
{
    // struct node_t root;
    // root.value = 4;
    // root.left = NULL;
    // root.right = NULL;
    struct node_t* root = insert(NULL, 4);

    insert(root, 2);
    insert(root, 5);
    insert(root, 1);
    insert(root, 3);
    insert(root, 7);

    visit(root);

    // search(root, 3);

     //print_bst(root, 0);

    return 0;
}