BINARY TREE FROM SCRATCH

/*********************************************************************************/
/*    MATHS PHYSIC CODE
/*    BINARY TREE FROM SCRATCH
/*********************************************************************************/

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

#define MAX(x, y)  (  ((x) > (y))  ? (x) : (y) ) //my max function using ternaire

//STEP 0: CREATE TREE STRUCT AND HIS NODE
//our binary tree 's node
typedef struct s_node {
    int val; //you can set any data type you want here, i will use int to make thing simple
    struct s_node *left;
    struct s_node *right;
}t_node;

//this is our binary tree struct
typedef struct {
    t_node *node_ptr; //tree is simply node pointer
}t_tree;

//STEP 1: INSERT NODE INSIDE TREE
void insert_inside_tree(  t_node **head, int dataToInsert){
    if(head){ //because i will dereference this pointer , i must be sure it is not null
        t_node *new_node = (t_node *)malloc(sizeof(t_node));
        if(NULL == new_node)
            return; //malloc failed, so we stop
        new_node->left = new_node->right = NULL;
        new_node->val = dataToInsert;
        if(NULL == *head){ //if tree is empty we add our node here
            *head = new_node;
            return;
        }
        //if tree is not empty, let's serach the suitable current sub tree ad insert
        if( dataToInsert < (*head)->val)
            insert_inside_tree( & (*head)->left, dataToInsert); //left recursif call
        else
            insert_inside_tree(&(*head)->right, dataToInsert); //right recursif call
    }
}



//STEP 2: DISPLAY OUR TREE IN LEVEL ORDER (AKA LINE BY LINE)
//we will display line by line so let's calculate the maxHheight aka line
unsigned int getTreeMaxHeight(t_node **head){
        if(NULL == *head)
            return (0);
        //let's find the max height in left or right sub tree
        return MAX( 1 + getTreeMaxHeight( &(*head)->left ),1 + getTreeMaxHeight(  &(*head)->right));
}

void _display_tree_utils(t_node **head, unsigned int level, int margin){
    if(head && *head){ //if head is not null
            if(level == 0){ //i simply print
                printf("%*d  ", margin, (*head)->val);
                return;
            }
            _display_tree_utils( &(*head)->left, level -1, 0.5 * margin);
            _display_tree_utils(&(*head)->right, level - 1, 0.8 * margin);
    }
}

void displayTree(t_tree *tree){
    unsigned int height = getTreeMaxHeight( &tree->node_ptr);
    int margin =  26; //you can change margin to display correctly

    for(unsigned int level = 0; level < height; level++){
        if( level & 1) //if level is odd number, i use bitwise cause it is fast than modulo
            printf("\x1B[31m"); //print in green color
        else
            printf("\x1B[32m"); //print in red color

            _display_tree_utils( &tree->node_ptr, level, margin );
            printf("\n\n");
    }
}

//STEP 3: DEALLOCATE MEMORY
void destroyTree(t_node **head){
        if(head && *head){ //if tree is not empty
            //we must destroy from dow to up
            destroyTree( &(*head)->left);
            destroyTree(&(*head)->right);
            free(*head);
            head= NULL;//to avoid dangling pointer
        }
}

//STEP 4: MAIN FUNCTION TO TEST
int main(){
    t_tree *tree = (t_tree *)malloc(sizeof(t_tree));
    if(tree){ //if malloc succeed
        tree->node_ptr = NULL; //at the begining, no node inside tree so pointer is null
        insert_inside_tree(  &tree->node_ptr, 12); //datas to insert to list
        insert_inside_tree(&tree->node_ptr, 8);
        insert_inside_tree(&tree->node_ptr, 17);
        insert_inside_tree(&tree->node_ptr, 6);
        insert_inside_tree(&tree->node_ptr, 10);
        insert_inside_tree(&tree->node_ptr, 16);
        insert_inside_tree(&tree->node_ptr, 18);
        insert_inside_tree(&tree->node_ptr, 5);
        insert_inside_tree(&tree->node_ptr, 7);

        //display result
        displayTree(tree);

        //free memory
        destroyTree(&tree->node_ptr); //destroy tree's t_node * datas
        free(tree); //destroy tree;
   }
    return (0);
}