Ajuda em AVL

[FernandoIuasse]

Estou com um trabalho de Estrutura de dados II para ser entregue, e minha remoçao não esta funcionando, já fiz ela inumeras vezes e nada de dar certo, todo o resto esta funcionando perfeitamente, alguém poderia dar uma dica do que estou fazendo errado? segue o meu codigo

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

#define N 100

typedef struct arvore{
   int bal;//armazena o fator de balançeamento
   int isbn;//armazena a isbn do livro
   char titulo[100];//armazena o titulo do livro
   char autor[100];//armazena o autor do livro
   int n_livros;//armazena a quantidade de livros
   struct arvore *esq;//aponta para o filho esquerdo da raiz
   struct arvore *dir;//aponta para o filho direito da raiz
}AVL;

//Inicio Prototipos
void primeiro_caso_avl(AVL **pt);
void segundo_caso_avl(AVL **pt);
int insere_avl(AVL **pt,int x);
AVL *aloca_no(int x);
void percurso_ordem(AVL *pt);
void percurso_pos_ordem(AVL *pt);
void remove_avl(AVL **pt,AVL **ptAux,int x);
int busca_avl(AVL *pt, int x);
void busca_remove_elemento_dir_AVL(AVL **pt,AVL **raiz,AVL **ptAux);
//Fim Prototipos

int h=0;//Variavel global de auxilio


int main(){
    AVL *arvore = NULL;//criar a arvore e inicializa com nulo
    int condicao,x;//variaveis 
    
    do{
                system("cls");
                printf("Escolha a opcao desejada:\n\n");
                printf("[1]Imprimir lista de livro ordem crescente\n");
                printf("[2]Inserir novo livro\n");
                printf("[3]Buscar livro no sistema\n");
                printf("[4]Imprimir estrutura da arvore\n");
                printf("[5]Excluir livro\n");
                printf("[0]Para Sair\n");
                scanf("%i",&condicao);
                switch(condicao){
                             case 0://Sair do programa
                                 printf("Finalizado");
                                 system("pause");
                                 return 0;
                                 break;
                                 
                             case 1://Imprimir lista de livro ordem crescente
                                  percurso_ordem(arvore);//usa-se percurso em ordem para imprimir ordenadamente e em forma crescente
                                  system("pause");
                                  break;
                                  
                             case 2://Inserir novo livro
                                  printf("\nDigite ISBN: ");
                                  scanf("%i",&x);
                                  insere_avl(&arvore,x);
                                  break;
                                  
                             case 3://Buscar livro no sistema
                                  printf("\nDigite numero a ser buscado:");
                                  scanf("%i",&x);
                                  busca_avl(arvore,x);
                                  system("pause");
                                  break;
                                  
                             case 4://Imprimir estrutura da arvore
                                  percurso_pos_ordem(arvore);
                                  system("pause");
                                  break;
                                  
                             case 5://Excluir
                                  printf("\nExcluir numero: ");
                                  scanf("%i",&x);
                                  remove_avl(&arvore,&arvore,x);   
                                  system("pause");
                                  break;
                }
        }while(condicao != 0);
    
}


AVL *aloca_no(int x){//alocamos e já inicializamos todos os dados
   AVL *novo;
   novo=(AVL *)malloc(sizeof(AVL));
   novo->bal=0;
   novo->isbn=x; 
   novo->esq=NULL;
   novo->dir=NULL;
   
   printf("\nDigite o Titulo:");
         fflush(stdin);
         fgets(novo->titulo,100,stdin);
         
   printf("\nDigite o nome dos Autor(es):");
         fflush(stdin);
         fgets(novo->autor,100,stdin);
  
   printf("\nDigite numero de livros:");
   scanf("%i",&novo->n_livros);
   
   return novo;
}

int insere_avl(AVL **pt, int x){
    
    
    if(*pt == NULL){
        *pt = aloca_no(x); 
        h=1;
    }
    else{        
        if(x == (*pt)->isbn){
                printf("Chave existente\n\n");
                return 0;
        }
        else{
            if(x < (*pt)->isbn){
                        insere_avl(&(*pt)->esq,x);
                if(h==1){ 
                        switch((*pt)->bal){
                                case -1:
                                    (*pt)->bal=0;
                                    h=0;
                                    break;
                                case 0:
                                    (*pt)->bal=1;
                                    break;
                                case 1:
                                    primeiro_caso_avl(&(*pt));
                                    break;
                        }
                }
            }
            else{
            insere_avl(&(*pt)->dir,x);
                    if(h==1){
                        switch((*pt)->bal){
                                case 1:
                                    (*pt)->bal=0;
                                    h=0;
                                    break;
                                case 0:
                                    (*pt)->bal=-1;
                                    break;
                                case -1:
                                    segundo_caso_avl(&(*pt));
                                    break;
                        }
                    }
            }
        }
    }
}

void primeiro_caso_avl(AVL **pt){
    AVL *ptu,*ptv;
    ptu = (*pt)->esq;
    
    if(ptu->bal == 1){//Altura(Te(u)) > Altura(Td(u))
        (*pt)->esq = ptu->dir;//rotacao a direita
        ptu->dir = *pt;
        (*pt)->bal = 0;
        *pt = ptu;
    }
    else{ //Alt(Te(u)) < Alt(Td(u))
        ptv = ptu->dir;//rotacao dupla a direita
        ptu->dir = ptv->esq;
        ptv->esq = ptu;
        (*pt)->esq = ptv->dir;
        ptv->dir = *pt;
        
        if(ptv->bal=1){//atualizacao do fator de balanceamento
            (*pt)->bal = -1;
        }
        else{
            (*pt)->bal = 0;
        }
        if(ptu->bal = -1){
            ptu->bal = 1;
        }
        else{
            ptu->bal = 0;
        }
        *pt=ptv;
    }
    
    (*pt)->bal = 0;
    h=0;
}

void segundo_caso_avl(AVL **pt){
    AVL *ptu,*ptv;
    ptu = (*pt)->dir;
    if(ptu->bal=-1){//rotacao a esquerda
         (*pt)->dir = ptu->esq;
         ptu->esq = *pt;
         (*pt)->bal=0;
         *pt = ptu;
    }
    else{//rotacao dupla esquerda
        ptv = ptu->esq;
        ptu->esq = ptv->dir;
        ptv->dir=ptu;
        (*pt)->dir=ptv->esq;
        ptv->esq=*pt;
        
        if(ptv->bal=-1){//atualizacao do fator de balanceamento
            (*pt)->bal=1;
        }        
        else{
            (*pt)->bal=0;
        }        
        if(ptv->bal=1){
            ptu->bal=-1;
        }
        else{
            ptu->bal=0;
        }
        *pt=ptv;
    }
    (*pt)->bal=0;
    h=0;
}


int  busca_avl(AVL *pt, int x){ 
    if(pt != NULL ){
           while (pt != NULL){

                if(pt->isbn < x){                
                    pt = pt->dir;
                }
                else if (pt->isbn > x){
                    pt = pt->esq;
                }
                else if(pt->isbn == x){
                    printf("Elemento encontrado");    
                    return 1;
                }
                else{
                    printf("Elemento não encontrado");
                    return 0;
                }
            }
    }
}

void  percurso_ordem(AVL *pt){
        if(pt != NULL){
                  percurso_ordem(pt->esq);
                  printf("\nISBN = %i\nTitulo = %sAutor = %sNumero = %i\n",pt->isbn, pt->titulo, pt->autor, pt->n_livros);
                  percurso_ordem(pt->dir);
        }
}

void percurso_pos_ordem(AVL *pt){
    if(pt != NULL){
        percurso_pos_ordem(pt->esq);
        percurso_pos_ordem(pt->dir);
        printf("\nISBN = %i\nBalanceamento = %i\n",pt->isbn, pt->bal);
    }
}

void busca_remove_elemento_dir_AVL(AVL **pt,AVL **raiz,AVL **ptAux){ //remove elemento esquerdo mais à direita
    AVL *remove;
    if((*pt)->dir != NULL){                            
                busca_remove_elemento_dir_AVL(&(*pt)->dir,&(*raiz),&(*pt));
                if(h==1){        
                        segundo_caso_avl(&(*pt));
                }
    }
    else{
        remove = *pt;
        (*raiz)->isbn = (*pt)->isbn;        
        *pt = (*pt)->esq;
        
        if(*pt != NULL){
                        (*ptAux)->esq = *pt;
        }
        (*raiz)->bal=-1;                   
        h = 1;
        free(remove);
    }
}

void remove_avl(AVL **pt,AVL **ptAux,int x){
    if(*pt == NULL){
        printf("Numero não Encontrado");
        h=0;
    }
    
    else{
        if((*pt)->isbn > x){
                        remove_avl(&(*pt)->esq,&(*pt),x);
            if(h==1){
                switch((*pt)->bal){
                                    case 1:
                                        (*pt)->bal=0;
                                        h=0;
                                        break;

                                    case 0:
                                        (*pt)->bal=-1;
                                        break;

                                    case -1:
                                        segundo_caso_avl(&(*pt));
                                        break;
                }
            }
        }
        else{
                    if((*pt)->isbn < x){                    
                                remove_avl(&(*pt)->dir,&(*pt),x);                                                     
                        
                        if(h==1){
                             switch((*pt)->bal){
                                        case -1:
                                            (*pt)->bal=0;
                                            h=0;
                                            break;
                                        case 0:
                                            (*pt)->bal=-1;

                                            break;
                                        case 1:
                                             primeiro_caso_avl(&(*pt));
                                             break;
                            }
                        }
                    }
                    
                    else{//elemento a ser removido

                    if((*pt)->dir == NULL){
                        if((*pt)->esq != NULL){                            
                               (*ptAux)->dir = (*pt)->esq;
                        }
                    h=1;
                    }
                    else{                        
                        if((*pt)->esq == NULL){                            
                            if((*pt)->dir != NULL){
                                (*ptAux)->esq = (*pt)->dir;
                             }
                            *pt = (*pt)->dir;
                        h=1;
                        }
                        else{                            
                            busca_remove_elemento_dir_AVL(&(*pt)->esq,&(*pt),&(*pt));                            
                            if(h==1){
                                 segundo_caso_avl(&(*pt));
                            }
                        }
                   }
              }
         }
    }
}