tree.c

#include "tree.h"

node_t *bst_create()
{
    // node_t* nd = malloc(1 * sizeof(node_t));
    // nd->val = -1;
    // nd->left = NULL;
    // nd->right = NULL;
    return NULL;
}

bool bst_is_bst(node_t *tree)
{
    if(tree == NULL) // Default is true
    {
        return true;
    }
    if(tree->left != NULL)
    {
        if(tree->val < tree->left->val) // Is not BST
        {
            return false;
        }
        return bst_is_bst(tree->left);
    }
    if(tree->left != NULL)
    {
        if(tree->val > tree->right->val) // Is not BST
        {
            return false;
        }
        return bst_is_bst(tree->right);
    }
}


int bst_find_min(node_t *tree)
{
    if(tree == NULL)
    {
        return INT_MIN;
    }
    if(tree->left != NULL)
    {
        return bst_find_min(tree->left);
    }
    else
    {
        return tree->val;
    }
}

int bst_find_max(node_t *tree)
{
    if(tree == NULL)
    {
        return INT_MIN;
    }
    if(tree->right != NULL)
    {
        return bst_find_max(tree->right);
    }
    else
    {
        return tree->val;
    }
}


node_t *bst_search(node_t *tree, int val)
{
    if(tree == NULL)
    {
        return NULL;
    }
    if(val == tree->val)
    {
        return tree;
    }
    if(val > tree->val) // Right
    {
        return bst_search(tree->right,val);
    }
    if(val < tree->val) // Left
    {
        return bst_search(tree->left,val);
    }
}

void bst_destroy(node_t *tree)
{
    if(tree == NULL){return;}

    if(tree->left != NULL)
    {
        bst_destroy(tree->left);
        tree->left = NULL;
    }
    if(tree->right != NULL)
    {
        bst_destroy(tree->right);
        tree->right = NULL;
    }
    
    if(tree->right == NULL && tree->left == NULL)
    {
        free(tree);
        tree = NULL;
    }
}

bool bst_is_empty(node_t *tree)
{
    return (tree == NULL)?true:false;
}

bool bst_is_present(node_t *tree, int val)
{
    if(tree == NULL){return false;}
    if(tree->val == val)
    {
        return true;
    }
    else
    {
        if(val > tree->val)
        {
            return bst_is_present(tree->right,val);
        }else
        {
            return bst_is_present(tree->left,val);
        }
    }
}

node_t *bst_insert(node_t *tree, int val)
{
    if(tree == NULL)
    {
        tree = malloc(1 * sizeof(node_t));
        tree->val = val;
        tree->right = NULL;
        tree->left = NULL;
        return tree;
    }
    
    if(val > tree->val) // Right
    {
        tree->right = bst_insert(tree->right,val);
    }
    else if(val < tree->val) // Left
    {
        tree->left = bst_insert(tree->left,val);
    }
    return tree;
}

uint32_t bst_lenght(node_t *tree)
{
    uint32_t length = 0;
    if(tree->left == NULL && tree->right == NULL && tree != NULL)
    {
        return 1;
    }
    else
    {
        if (tree->left != NULL) {
            length += bst_lenght(tree->left);
        }
        if(tree->right != NULL){
            length += bst_lenght(tree->right);
        }
    }
    return length;
}