Реализовать (без использования контейнеров STL) Б-дерево со вставкой и удалением элементов

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
const int DEGREE = 3;
 
const int MAX_DATA_IN_NODE = 2 * DEGREE - 1;
const int MIN_DATA_IN_NODE = DEGREE - 1;
 
const int MAX_CHILDREN = 2* DEGREE;
 
const int DATA_NUM_TO_CREATE = (int)( (MAX_DATA_IN_NODE + MIN_DATA_IN_NODE) / 2 );
 
typedef struct TVector {
 
    char* str;
 
    unsigned long long value;
}TVector;
 
TVector* Realloc(TVector* pointer, int size) {
 
    TVector* new_pointer = (TVector*)realloc(pointer, size * sizeof(TVector));
    if (new_pointer == NULL) {
        free(pointer);
    }
    return new_pointer;
}
 
 
typedef struct TNode {
 
    TVector* data;    // vector of data
    int numOfData;    // number of data
    int maxData;      // max number of data
 
    struct TNode** children; /* max (2*t) children */
    bool leaf;    // = 1 if this a leaf node
}TNode;
 
TNode* NodeCreate() {
    TNode* node;
 
    node = (TNode*)malloc(sizeof(TNode));
 
    node->numOfData = 0;
    node->maxData = MAX_DATA_IN_NODE;
    node->data = (TVector*)malloc(MAX_DATA_IN_NODE * sizeof(TVector));
 
    node->children = (TNode**)malloc(sizeof(TNode*) * MAX_CHILDREN);
    node->leaf = true;
    return node;
}
 
long long Search(TNode* root, char* key) {
    printf("search \n");
    int i = 0;
    int cmp;
    while( i < root->numOfData ) {
        cmp = strcasecmp(key, root->data[i].str);
        if(cmp >= 0) {
            break;
        }
 
    }
    if(cmp == 0) {
        return root->data->value;
    }
    else {
        if(root->leaf) {
            return -1;
        }
        else {
            Search(root->children[i], key);
        }
    }
    return -1;
}
 
void SplitChild(TNode* node, int cnt) {
// printf("Split Child\n");
    TNode* node1; //z
    TNode* node2; //y
 
    node1 = NodeCreate();
    node2 = node->children[cnt];
    node1->leaf=node2->leaf;
 
    node1->numOfData = MIN_DATA_IN_NODE;
    int i = 0;
    for(i = 0; i < MIN_DATA_IN_NODE; ++i) {
        node1->data[i] = node2->data[i + DEGREE];
    }
    if(!node2->leaf) {
        for(i=0; i < DEGREE; ++i) {
 
            node1->children[i] = node2->children[i + DEGREE];
        }
    }
    node2->numOfData = MIN_DATA_IN_NODE;
 
    for (i = node->numOfData; i >= cnt + 1 ; --i) {
        node->children[i + 1] = node->children[i];
    }
    node->children[i + 1] = node1;
 
    for (i = node->numOfData - 1; i >= cnt ; --i) {
        node->data[i + 1] = node->data[i];
    }
    node->data[cnt] = node2->data[DEGREE-1];
    node->numOfData++;
}
 
void InsertNotFull(TNode* node, TVector elem) {
 //   printf("ins not full \n");
    int i = node->numOfData - 1;
    if(node->leaf) {
        while( i >= 0 ) {
            int cmp = strcasecmp(elem.str, node->data[i].str);
            if(cmp >= 0) {
                break;
            }
            node->data[i + 1] = node->data[i];
            i--;
        }
        node->data[i + 1].value = elem.value;
        node->data[i + 1].str = (char*)malloc(258*sizeof(char));
        strcpy(node->data[i + 1].str,elem.str);
        node->numOfData++;
        return;
    }
    else {
        while( i >= 0 ) {
            int cmp = strcasecmp(elem.str,node->data[i].str);
            if( cmp >= 0 ) {
                break;
            }
                i--;
        }
        i++;
        if(node->children[i]->numOfData == MAX_DATA_IN_NODE ) {
            SplitChild(node,i);
            if( strcasecmp(elem.str,node->data[i].str) > 0 ) {
                i++;
            }
        }
        InsertNotFull(node->children[i],elem);
    }
}
 
void Insert(TNode* root, TVector elem){
//    printf("ins \n");
    if(Search(root,elem.str) != -1) {
        printf("Exist\n");
        return;
    }
    else {
 
        TNode* root1 = root;
        if(root->numOfData == MAX_DATA_IN_NODE) {
            TNode* l = NodeCreate();
            root = l;
            l->leaf = false;
            l->numOfData = 0;
            l->children[0] = root1;
            SplitChild(l,0);
            InsertNotFull(l,elem);
        }
        else {
            InsertNotFull(root,elem);
        }
    }
 
}
 
void Print(TNode* root) {
    int j = 0;
    for (int i = 0; i < root->numOfData; ++i) {
        j++;
        if(!root->leaf) {
            Print(root->children[i]);
        }
        printf("%s  %llu\n",root->data[i].str,root->data[i].value);
    }
    if(!root->leaf) {
        Print(root->children[j]);
    }
}
 
 
void Delete(TNode* tree) {
    int j = 0;
    for (int i = 0; i < tree->numOfData; ++i) {
        j++;
        if(!tree->leaf) {
            Delete(tree->children[i]);
        }
        for(int x = 0; x < tree->numOfData; x++ ) {
            free(tree->data[i].str);
        }
        free(tree->data);
        if(!tree->leaf) {
            for(int x=0; x < tree->numOfData + 1; x++) {
                free(tree->children[i]);
            }
        }
        free(tree->children);
    }
    if(!tree->leaf) {
        Delete(tree->children[j]);
    }
printf("deleted\n");
}
 
int main() {
    TNode* tree = NodeCreate();
    TVector elem1;
    elem1.str = (char *) malloc(257 * sizeof(char));
    for(unsigned long long i=1; i < 10; ++i) {
        elem1.value = i;
        char c=(char)(i+65);
        elem1.str[0]=c;
        elem1.str[1]='\0';
        Insert(tree,elem1);
        Print(tree);
    }
    /*for(int i=1; i < 10; i++) {
        elem1.str[0]=(char)(i+65);
        long long a = Search(tree,elem1.str);
        printf("%d: %lli",i,a);
    }*/
 
    //free(elem1.str);
    //Print(tree);
    //Delete(tree);
}