Delete root of a binary search tree

Question

Im working on a program in C that reads a binary tree from a file and opperates functions on it:insert elements,delete elements,search elements,display elements

With my old debugger it seems that i have 4 warnings and i dont know kow to fix them

Here is the code

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef struct bst
{
    double number;
    struct bst *leftChild;
    struct bst *rightChild;

} node;

node *root = NULL;


void insertNode(double value);
void preOrderPrint(node *root);
node * findMinimum(node *root);
node * deleteNode(node *root, double value);
node* search(node ** tree, double val);

int main()
{
    char line[255];
    char* endptr;
    FILE* f = fopen("tree.txt", "r");
    while (fgets(line, sizeof(line), f))
    {
        if  (*line!='*')
        {
                if(strtod (line, &endptr))
                    insertNode(strtod (line, &endptr));
                    else if (strtoimax(line,&endptr,0))
                    insertNode((strtoimax(line,&endptr,0)));
                    else
                    insertNode( strtol (line, &endptr,0));
        }

    }
    fclose(f);
    int flag = 0, key;
    int choice = 0;
    do
        {
        printf("\nEnter your choice:\n1. Display tree\n2. Insert node\n3. Delete node\n4. Exit\nChoice: ");
        scanf("%d", &choice);
            switch(choice)
            {
            case 1:
                printf("In Order Display\n");
                preOrderPrint(root);
            break;

            case 2:
            printf("Enter key to insert: ");
            scanf("%d",&key);
            flag = search(&root,key);
            if (flag)
                {
                printf("Key found in tree,cannot insert\n");
                }
                else
                {
                printf("Node %d was inserted \n",key);
                insertNode(key);
                preOrderPrint(root);
                }
            break;

            case 3:
            printf("Enter key to delete: ");
            scanf("%d", (int*)&key);
            flag = search(&root, key);
            if (!flag)
                {
                printf("Key not found in tree,cannot delete\n");
                }
                else
                {
                printf("Node %d was deleted \n",key);
                deleteNode(root,key);
                preOrderPrint(root);
                }
            break;
            case 4:
            printf("Memory Cleared\nPROGRAM TERMINATED\n");
            break;
            default: printf("Not a valid input, try again\n");
            }
        }
 while (choice != 5);
    return 0;
}


node * deleteNode(node *currentNode, double value)
{
    if(currentNode==NULL) // empty tree
        return NULL;
    else if(value < currentNode->number) // value is less than node's number. so go to left subtree
        currentNode->leftChild = deleteNode(currentNode->leftChild, value);
    else if(value > currentNode->number) // value is greater than node's number. so go to right subtree
        currentNode->rightChild = deleteNode(currentNode->rightChild, value);
    else // node found. Let's delete it!
    {
        //node has no child
        if(currentNode->leftChild == NULL && currentNode->rightChild == NULL)
        {
            currentNode = NULL;
        }
        else if(currentNode->leftChild == NULL) // node has only right child
        {
            currentNode = currentNode->rightChild;
        }
        else if(currentNode->rightChild == NULL) // node has only left child
        {
            currentNode = currentNode->leftChild;
        }
        else // node has two children
        {
            node *tempNode = findMinimum(currentNode->rightChild);
            currentNode->number = tempNode->number;
            currentNode->rightChild = deleteNode(currentNode->rightChild, tempNode->number);
        }

    }

    return currentNode;
}

node * findMinimum(node *currentNode)
{
    if(currentNode->leftChild==NULL)
        return currentNode;

    return findMinimum(currentNode->leftChild);
}

void insertNode(double value)
{


    node *tempNode;
    node *currentNode;
    node *parentNode;

    tempNode = (node *) malloc(sizeof(node));
    tempNode->number = value;
    tempNode->leftChild = NULL;
    tempNode->rightChild = NULL;

    //For the very first call
    if(root==NULL)
    {
        root = tempNode;
    }
    else
    {
        currentNode = root;
        parentNode = NULL;

        while(1)
        {
            parentNode = currentNode;

            if(value <= parentNode->number)
            {
                currentNode = currentNode->leftChild;

                if(currentNode==NULL)
                {
                    parentNode->leftChild = tempNode;
                    return;
                }
            }
            else
            {
                currentNode = currentNode->rightChild;

                if(currentNode==NULL)
                {
                    parentNode->rightChild = tempNode;
                    return;
                }
            }

        }
    }
}


void preOrderPrint(node *root)
{
    if(root==NULL)
        return;



    preOrderPrint(root->leftChild);
    printf("%g ", root->number);
    preOrderPrint(root->rightChild);
}


node* search(node ** tree, double val)
{
    if(!(*tree))
    {
        return NULL;
    }

    if(val < (*tree)->number)
    {
        search(&((*tree)->leftChild), val);
    }
    else if(val > (*tree)->number)
    {
        search(&((*tree)->rightChild), val);
    }
    else if(val == (*tree)->number)
    {
        return *tree;
    }
    //return true;
}

C:\UsersX\Desktop\39\main.c|32|warning: implicit declaration of function 'strtoimax' [-Wimplicit-function-declaration]|

C:\UsersX\Desktop\39\main.c|56|warning: assignment makes integer from pointer without a cast [-Wint-conversion]|

C:\UsersX\Desktop\39\main.c|72|warning: assignment makes integer from pointer without a cast [-Wint-conversion]|

C:\UsersX\Desktop\39\main.c|224|warning: control reaches end of non-void function [-Wreturn-type]| ||=== Build finished: 0 error(s), 4 warning(s) (0 minute(s), 0 second(s)) ===|

Also the main question would be why i cannot delete the root? With my debugger it seems that the root can be deleted.