Estrutura de Dados - Arvore AVL

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

/*
/@autor: Shouldz
/@Linguagem: C
/@Descrição: [Estrutura de Dados] Árvore AVL com operação de inserção recursiva.
*/

typedef struct no{
    int valor;
    int fb;
    struct no *dir;
    struct no *esq;
}no;

no *criar_no(int valor, int *cresceu){
    no *criar_no = malloc(sizeof(no));
    criar_no -> valor = valor;
    criar_no -> fb = 0;
    criar_no -> dir = NULL;
    criar_no -> esq = NULL;
    *cresceu = 1;
    return criar_no;
}

no *rotacao_simples_direita(no *pivo){
    no *u = pivo -> esq;
    no *t2 = u -> dir;
    u -> fb = 0;
    pivo -> fb = 0;
    pivo -> esq = t2;
    u -> dir = pivo;
    return u;
}

no *rotacao_simples_esquerda(no *pivo){
    no *u = pivo -> dir;
    no *t2 = u -> esq;
    u -> fb = 0;
    pivo -> fb = 0;
    pivo -> dir = t2;
    u -> esq = pivo;
    return u;
}

no *rotacao_dupla_direita(no *pivo){
    //situação inicial da arvore
    no *u = pivo -> esq;
    no *v = u -> dir;
    no *t2 = v -> dir;
    no *t3 = v -> esq;
    switch(v -> fb){
        //alteração do fator de balanço referente ao final
        case 0:
            //caso V tenha os dois filhos
            v -> fb = 0;
            u -> fb = 0;
            pivo -> fb = 0;
            break;
        case 1:
            //caso V tenha apenas filho direito
            v -> fb = 0;
            u -> fb = -1;
            pivo -> fb = 0;
            break;
        case -1:
            //caso V tenha apenas filho esquerdo
            v -> fb = 0;
            u -> fb = 0;
            pivo -> fb = 1;
            break;
    }
    //situação final da arvore
    v -> dir = pivo;
    v -> esq = u;
    pivo -> esq = t2;
    u -> dir = t3;
    return v;
}

no *rotacao_dupla_esquerda(no *pivo){
    no *u = pivo -> dir;
    no *v = u -> esq;
    no *t2 = v -> esq;
    no *t3 = v -> dir;
    switch(v -> fb){
        //alteração do fator de balanço referente ao final
        case 0:
            //caso V tenha os dois filhos
            v -> fb = 0;
            u -> fb = 0;
            pivo -> fb = 0;
            break;
        case 1:
            //caso V tenha apenas filho direito
            v -> fb = 0;
            pivo -> fb = -1;
            u -> fb = 0;
            break;
        case -1:
            //caso V tenha apenas filho esquerdo
            v -> fb = 0;
            pivo -> fb = 0;
            u -> fb = 1;
            break;
    }
    v -> dir = u;
    v -> esq = pivo;
    u -> esq = t3;
    pivo -> dir = t2;
    return v;
}

no *balanceamento(no *pivo) {
    //responsavel por definir qual rotação será realizada
    if(pivo->fb == -2 && pivo->esq->fb == -1){
        return rotacao_simples_direita(pivo);
    }else if(pivo -> fb == 2 && pivo -> dir -> fb == 1){
        return rotacao_simples_esquerda(pivo);
    }else if(pivo -> fb == -2 && pivo -> esq -> fb == 1){
        printf("DISPAROU DUPLO DIREITA");
        return rotacao_dupla_direita(pivo);
    }else if(pivo -> fb == 2 && pivo -> dir -> fb == -1){
        printf("DISPAROU DUPLO ESQUERDA");
        return rotacao_dupla_esquerda(pivo);
    }
}


no *inserir(no *raiz, int valor, int *cresceu){
    //caso base
    if(raiz == NULL){
        return criar_no(valor, cresceu);
    }else{
         //procurar local para o valor, percorrendo as sub-arvores
        if(valor > raiz -> valor){
            raiz -> dir = inserir(raiz -> dir, valor, cresceu);
            if(*cresceu){
                //calculo de fator de balanço, alterando o fator
                switch(raiz -> fb){
                    case 0:
                        raiz -> fb = 1;
                        *cresceu = 1;
                        break;
                    case 1:
                        raiz -> fb = 2;
                        *cresceu = 0;
                        //balanceamento chamado para rotacionar a arvore
                        return balanceamento(raiz);
                        break;
                    case -1:
                        raiz -> fb = 0;
                        *cresceu = 0;
                        break;
                }
            }
        }else{
            raiz -> esq = inserir(raiz -> esq, valor, cresceu);
            if(*cresceu){
                //calculo de fator de balanço, alterando o fator, de maneira analoga a anterior
                switch(raiz -> fb){
                    case 0:
                        raiz -> fb = -1;
                        *cresceu = 1;
                        break;
                    case 1:
                        raiz -> fb = 0;
                        *cresceu = 0;
                        break;
                    case -1:
                        raiz -> fb = -2;
                        *cresceu = 0;
                        //balanceamento chamado para rotacionar a arvore
                        return balanceamento(raiz);
                        break;
                }
            }
        }
        return raiz;
    }
}

void preorder(no *arvore){
    if(arvore != NULL){
        printf("[%d fb = %d]", arvore -> valor, arvore -> fb);
        preorder(arvore -> esq);
        preorder(arvore -> dir);
    }
}

void main(){
    no *arvore = NULL;
    int cresceu;
    int vetor[] = {50, 20, 15, 70, 45, 32, 27, 37, 12, 18, 21};
    for(int i = 0; i < 11; i++){
        arvore = inserir(arvore, vetor[i], &cresceu);
        preorder(arvore);
        printf("\n======================================================\n");
    }
}