Código C de Árvore Binária

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

#include <stdio.h> //declaração da bibliotecas
#include <stdlib.h>
#include <string.h>
struct arvore{ //estrutura da árvore
 int info; //campo para armazenar o valor do nó
 int fb; //campo para inserir o fator de balanceamento do nó
	 int nivel; //campo para armazenar o nível do nó
 struct arvore *fe,*fd; //ponteiros que ligam os nós
 }; //chamados de "filho esquerdo" e "filho direito"
struct arvore *p,*y,*z; //ponteiro que recebe a alocação da memória na função "inserção"
struct arvore *tree,*treed; //ponteiro que aponta para toda a estrutura da árvore
struct arvore *raiz,*raizd; //ponteiro que aponta para a raíz da árvore
int num_folhas=0,num_nos=0,maior_nivel=0,verifica_folhas=0; //conta o número de folhas e nós da árvore
int vetor[100],posicao=0;
int nos_nivel=0,nivel_inserir=1,inseri=0;
void limpa();
//______________________LIMPA TELA_____________________________________________
void limpa(){
 if(system("clear")){
 system("clear");
 }else{
 system("cls");
 }
}
//______________________ INIT __________________________________________________
struct arvore *init(struct arvore *t){ //inicializa a árvore com o valor "NULL"
 t=NULL;
 return t;
}
//___________________________ INSERE ___________________________________________
struct arvore *insere(struct arvore *t,int x)
{
 if(t!=NULL){ //neste caso o nó "t" não é nulo, ou seja, é um nó já existente na árvore
 if(x>t->info){ //busca-se então um "local" vazio para inserir um novo nó
 t->fd=insere(t->fd,x); //se o valor a ser inserido for maior do que o já existente
 printf("\n\t\t Lado Direito"); //no nó da árvore, então o valor a ser inserido ficará a
 getchar(); //direita deste nó
 t->fb+=1; //calcula o valor do balanceamento do nó
 } //como é para a direita incrementa-se "1" ao valor "fb" já existente
 else
 if(x<t->info){ //caso o valor a ser inserido seja menor do que o do nó existente
 t->fe=insere(t->fe,x); //então o nó a ser inserido ficará a esquerda deste nó
 printf("\n\t\t Lado Esquerdo"); //assim então é feita uma inserção ordenada!!!
 getchar();
 t->fb+=-1; //calcula o valor do balanceamento do nó
 } //como é para a esquerda incrementa-se "-1" ao valor "fb" já existente
 else{
 printf("\n\t\t Este Numero ja Existe !!"); //não permite que um número já inserido
 getchar(); //seja inserido novamente
 return t;
 }
 } //if
 else{
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(1);
 }
 if(raiz==NULL){ //se a raiz for nula, então o valor é inserido na raiz
 p->info=x; //isto ocorre quando a árvore está vazia
 p->fd=p->fe=NULL;
 p->fb=0;
 raiz=p;
 }
 else{
 p->info=x; //caso contrário o novo nó torna-se uma folha
 p->fd=p->fe=NULL;
 p->fb=0;
 }
 return p; //retorna o ponteiro "p" para a função recursiva "insere"
 }//else
 return t; //retorna o ponteiro "t" para a função "main", neste caso a inserção
} //já foi executada completamente
//___________________________ ARMAZENA BALANCEADO ______________________________
struct arvore *armazena_balanceado(struct arvore *t,int nivel,int x){
 if(t->fe!=NULL)
 t->fe=armazena_balanceado(t->fe,nivel+1,x);
 if(t->fd!=NULL)
 t->fd=armazena_balanceado(t->fd,nivel+1,x);
 if(nivel==nivel_inserir-1){
 if(inseri==0){
 if(t->fe==NULL){
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(2);
 }
 p->info=x;
 p->fe=NULL;
 p->fd=NULL;
 t->fe=p;
 inseri=1; //indica que inseriu
 }
 else{
 if(t->fd==NULL){
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(2);
 }
 p->info=x;
 p->fe=NULL;
 p->fd=NULL;
 t->fd=p;
 inseri=1; //indica que inseriu
 }
 }
 }
 }
 return t;
}
//___________________________ INSERE BALANCEADO ________________________________
struct arvore *insere_balanceado(struct arvore *t,int x){
 int i;
 if(raizd==NULL){
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(2);
 }
 p->info=x; //insere na raiz
 p->fe=NULL;
 p->fd=NULL;
 raizd=p;
 t=raizd;
 }
 else{
 if(raizd->fe==NULL){
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(2);
 }
 p->info=x;
 p->fe=NULL; //insere a esquerda da raiz
 p->fd=NULL;
 raizd->fe=p;
 }
 else{
 if(raizd->fd==NULL){ //insere a direita da raiz
 p=(struct arvore*)malloc(sizeof(struct arvore)); //aloca espaço na memória
 if(p==NULL){
 printf("\n\t\t Falha "); //verifica se a alocação foi sucedida
 getchar();
 exit(2);
 }
 p->info=x;
 p->fe=NULL;
 p->fd=NULL;
 raizd->fd=p;
 }
 else{
 if(nos_nivel==0){ //é necessário calcular o novo nº de nós do próximo nível
 nos_nivel=1;
 nivel_inserir+=1;
 for(i=nivel_inserir;i>0;i--)
 nos_nivel*=2;
 t=armazena_balanceado(raizd,0,x);
 nos_nivel--;
 }
 else{
 t=armazena_balanceado(raizd,0,x);
 nos_nivel--;
 }
 }
 }
 }
}
//__________________________ ENTRAR VALORES BALANCEADO _________________________
void entrar_valores_balanceado(){
 char opcao[3];
 int num;
 do{
 limpa();
 printf("\n\n\t\t Digite um Valor:"); //entra com os valores a serem inseridos
 scanf("%d",&num);
 treed=insere_balanceado(treed,num); //chama-se a função inserir balanceado
 inseri=0;
 printf("\n\n\t\t Continuar: (S/N)"); //verifica-se a continuidade da inserção
 printf("\n\t\t Opcao[ ]\b\b");
 scanf("%s",opcao);
 }while((strcmp(opcao,"s")==0)||(strcmp(opcao,"S")==0)); //repete-se enquanto se quiser inserir
 getchar();
}
//______________________ ROTAÇÃO _______________________________________________
struct arvore *rotacao(struct arvore *t){
 if(t->fb>=2){
 if(t->fd->fe==NULL){ //o filho direito do nó desbalanceado não tem filho
 t->fd->fe=t; //esquerdo
 t->fd->fb=t->fb=0; //após balancear os nós, seus fatores de balanceamento
 t->fd=NULL; //são atualizados com "0" para indicar que estão balanceados
 }
 else{
 t->fd->fe->fd=t->fd; //o filho direito do nó desbalanceado tem filho
t->fd->fe->fe=t; //esquerdo
 t->fd->fb=t->fb=0; //atualiza o FB com "0"
 t->fd->fe=t->fd=NULL;
 }
 }//if
 else{
 if(t->fe->fd==NULL){ //o filho esquerdo do nó desbalanceado não tem filho
 t->fe->fd=t; //direito
 t->fe->fb=t->fb=0; //atualiza o FB com "0"
 t->fe=NULL;
 }
 else{
 t->fe->fd->fe=t->fe; //o filho esquerdo do nó desbalanceado tem filho
 t->fe->fd->fd=t; //direito
 t->fe->fb=t->fb=0; //atualiza o FB com "0"
 t->fe->fd=t->fe=NULL;
 }
 }//else
}
//____________________________ VERIFICA BALANCEAMENTO __________________________
struct arvore *verifica_balanceamento(struct arvore *t){
 if(t->fe!=NULL)
 verifica_balanceamento(t->fe); //verifica todos os nós esquerdos
 if(t->fd!=NULL)
 verifica_balanceamento(t->fd); //verifica todos os nós direitos
 if(t->fb>=2||t->fb<=-2) //verifica o fator de balanceamento de todos
 rotacao(t); //os nós da árvore
 return(t);
}
//_________________________ LISTAR ____________________________________________
struct arvore *listar(struct arvore *t){//, int pos, int fil){
 
 if(t==raiz){
 printf("\n\t Raiz: %d ",t->info); //o nó listado é a raiz
 }
 if(t->fe!=NULL) //busca todos os nós esquerdos da árvore
 listar(t->fe);
 if(t->fd!=NULL) //busca todos os nós direitos da árvore
 listar(t->fd); //,pos+1,2);
 if(t!=raiz){ //imprime todos os nós não-raízes, pois a raíz já foi listada
	printf("\n\t\t %d",t->info); 	
 getchar();
 }
 return(t);
 getchar();
}
struct arvore *listar_direto(struct arvore *t){//, int pos, int fil){
 
 if(t==raizd){
 printf("\n\t Raiz: %d ",t->info); //o nó listado é a raiz
 }
 if(t->fe!=NULL) //busca todos os nós esquerdos da árvore
 listar_direto(t->fe);
 if(t->fd!=NULL) //busca todos os nós direitos da árvore
 listar_direto(t->fd); //,pos+1,2);
 if(t!=raizd){ //imprime todos os nós não-raízes, pois a raíz já foi listada
	 printf("\n\t\t %d",t->info);
 getchar();
 }
 return(t);
 getchar();
}
//________________________ LISTAR EM ORDEM _____________________________________
void listar_em_ordem(struct arvore *t){
 if(t!=NULL){ //lista filho esquerdo, pai
 listar_em_ordem(t->fe); //e filho direito
 printf("\n\t\t %d",t->info);
 listar_em_ordem(t->fd);
 } 
 getchar();
}
//________________________ LISTAR EM PÓS ORDEM _________________________________
void listar_em_pos_ordem(struct arvore *t){
 if(t!=NULL){
 listar_em_pos_ordem(t->fe); //lista o filho esquerdo, o filho direito
 listar_em_pos_ordem(t->fd); //e o pai
 printf("\n\t\t %d",t->info);
 }
 getchar();
}
//________________________ LISTAR EM PRÉ ORDEM _________________________________
void listar_em_pre_ordem(struct arvore *t){
 if(t!=NULL){ //lista o pai, o filho esquerdo
 printf("\n\t\t %d",t->info); //e o filho direito
 listar_em_pre_ordem(t->fe);
 listar_em_pre_ordem(t->fd);
 } 
 getchar();
}
//____________________________ INICIALIZA VETOR ________________________________
void inicializa_vet(){
 int i;
 for(i=0;i<100;i++){
 vetor[i]=0;
 }
}
//____________________________ INSERE VETOR ____________________________________
struct arvore *insere_vetor(struct arvore *t,int nivel){
 
 t->nivel=nivel;
 printf("\n\n\t\t %d tem numeracao %d",t->info,nivel);
 if(nivel>maior_nivel){
 maior_nivel=nivel;
 } 	 
 if(t->fe!=NULL)
 insere_vetor(t->fe,nivel+1);
 if(t->fd!=NULL)
 insere_vetor(t->fd,nivel+1);
 getchar();
}
//__________________________ NUMERAÇÃO _________________________________________
struct arvore *numeracao(struct arvore *t,int nivel){
 
 t->nivel=nivel;
 printf("\n\n\t\t %d tem numeracao %d",t->info,nivel);
 if(t->fe!=NULL){
 insere_vetor(t->fe,nivel+1);
 } 
 if(t->fd!=NULL){
 insere_vetor(t->fd,nivel+1);
 } 
 getchar();
}
//__________________________ FOLHAS MAIOR NÍVEL ________________________________
void folhas_maior_nivel(struct arvore *t,int nivel){
 if(t->fe!=NULL)
 folhas_maior_nivel(t->fe,nivel+1);
 if(t->fd!=NULL)
 folhas_maior_nivel(t->fd,nivel+1);
 if(nivel==maior_nivel){
 if(t->fe==NULL&&t->fd==NULL){
 verifica_folhas++; //conta folhas do nivel mais profundo
 }
 }
}
//__________________________ CONTAR NOS ________________________________________
void contar_nos(struct arvore *t, int nivel){
 if(t->fe!=NULL)
 contar_nos(t->fe,nivel+1); //verifica todos os nós esquerdos
 if(t->fd!=NULL)
 contar_nos(t->fd,nivel+1); //verifica todos os nós direitos
 num_nos++; //conta o numero de nos
 if(t->fd==NULL&&t->fe==NULL){
 num_folhas++; //verifica o número de folhas da árvore
 if(maior_nivel<nivel) //verifica o nível mais profundo da árvore
 maior_nivel=nivel;
 }
}
//________________________ VERIFICA CLASSIFICAÇÃO ______________________________
void verifica_classificacao(){
 int i,tfn;
 contar_nos(tree,0);
 folhas_maior_nivel(tree,0);
 printf("\n\t\t Total de Folhas eh: %d",num_folhas);
 printf("\n\n\t\t Total de Nos eh: %d",num_nos);
 if(num_nos==2*num_folhas-1)
 printf("\n\n\t\t Arvore Estritamente Binaria");
 else printf("\n\n\t\t Arvore Nao Estritamente Binaria");
 if(maior_nivel>0){ //trata o nivel 0 separadamente
 i=maior_nivel;
 tfn=1;
 while(i>0){
 tfn*=2; //calcula o total de folhas que devem existir no maior nivel
 i--; //da árvore
 }
 if(verifica_folhas==tfn) //verifica se o total de folhas no maior nível
 printf("\n\n\t\t Arvore Completa"); //é igual ao numero de folhas suportado por este nível
 } //se for a arvore é completa
 else printf("\n\n\t\t Arvore Completa"); //se tem só raiz e possuir 2 nós filhos
 getchar();
}
//__________________________ ENTRAR VALORES ____________________________________
void entrar_valores(){
 char opcao[3];
 int num;
 do{
 limpa();
 printf("\n\n\t\t Digite um Valor:"); //entra com os valores a serem inseridos
 scanf("%d",&num);
 tree=insere(tree,num); //chama-se a função inserir
 printf("\n\n\t\t Continuar: (S/N)"); //verifica-se a continuidade da inserção
 printf("\n\t\t Opcao[ ]\b\b");
 scanf("%s",opcao);
 }while((strcmp(opcao,"s")==0)||(strcmp(opcao,"S")==0)); //repete-se enquanto se quiser inserir
 getchar();
}
//______________________________ FAMILIARIDADE _________________________________
struct arvore *familiaridade(struct arvore *t,int x, int nivel){
 if(x>t->info){
 if(t->fd!=NULL){
 y=p;
 p=t;
 t->fd=familiaridade(t->fd,x,nivel+1);
 }
 else printf("numero inexistente");
 }
 else{
 if(x<t->info){
 if(t->fe!=NULL){
 y=p;
 p=t;
 t->fe=familiaridade(t->fe,x,nivel+1);
 }
 else printf("\n\n\t\t numero inexistente");
 } //if
 else{ //achou o numero verifica seus descendentes (filhos e netos)
 if(t==raizd||t==raiz){
 printf("\n\n\t\t %d eh raiz portanto nao tem irmao nem sobrinho",t->info);
 printf("\n\n\t\t nivel de %d eh %d",t->info,nivel);
 }
	 if(t->fe==NULL&&t->fd==NULL)
 printf("\n\n\t\t %d eh folha",t->info);
 if(t->fe!=NULL){
printf("\n\n\t\t %d eh filho esquerdo de %d",t->fe->info,t->info);
 printf("\n\n\t\t nivel do filho eh: %d, nivel do pai eh: %d",nivel+1,nivel);
 if(t->fe->fe!=NULL)
 printf("\n\n\t\t %d eh neto esquerdo de %d",t->fe->fe->info,t->info);
 if(t->fe->fd!=NULL)
 printf("\n\n\t\t %d eh neto esquerdo de %d",t->fe->fd->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem filho nem netos esquerdo",t->info);
 if(t->fd!=NULL){
 printf("\n\n\t\t %d eh filho direito de %d",t->fd->info,t->info);
 printf("\n\n\t\t nivel do filho eh: %d, nivel do pai eh: %d",nivel+1,nivel);
 if(t->fd->fd!=NULL)
 printf("\n\n\t\t %d eh neto direito de %d",t->fd->fd->info,t->info);
 if(t->fd->fe!=NULL)
 printf("\n\n\t\t %d eh neto direito de %d",t->fd->fe->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem filho nem netos direito",t->info);
 //descobre os ancestrais (tios e avô) primos e sobrinhos
 if(p!=NULL){ //descobre irmao e sobrinhos
 printf("\n\n\t\t %d eh pai de %d",p->info,t->info);
 printf("\n\n\t\t nivel do pai eh: %d, nivel do filho eh: %d",nivel-1,nivel);
 if(p->fe!=t){
 if(p->fe!=NULL){
 printf("\n\n\t\t %d eh irmao de %d",p->fe->info,t->info);
 if(p->fe->fe!=NULL)
 printf("\n\n\t\t %d eh sobrinho de %d",p->fe->fe->info,t->info);
 if(p->fe->fd!=NULL)
 printf("\n\n\t\t %d eh sobrinho de %d",p->fe->fd->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem irmao nem sobrinhos",t->info);
 }//if
 else{
 if(p->fd!=NULL){
 printf("\n\n\t\t %d eh irmao de %d",p->fd->info,t->info);
 if(p->fd->fe!=NULL)
 printf("\n\n\t\t %d eh sobrinho de %d",p->fd->fe->info,t->info);
 if(p->fd->fd!=NULL)
 printf("\n\n\t\t %d eh sobrinho de %d",p->fd->fd->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem irmao nem sobrinhos",t->info);
 }//else
 //descobre tios e primos
 if(y!=NULL&&y!=p){
 printf("\n\n\t\t %d eh avo de %d",y->info,t->info);
 printf("\n\n\t\t nivel do avo eh: %d, nivel do neto eh: %d",nivel-2,nivel);
 if(y->fe==p){
 if(y->fd!=NULL){
 printf("\n\n\t\t %d eh tio de %d",y->fd->info,t->info);
 if(y->fd->fd!=NULL)
 printf("\n\n\t\t %d eh primo de %d",y->fd->fd->info,t->info);
 if(y->fd->fe!=NULL)
 printf("\n\n\t\t %d eh primo de %d",y->fd->fe->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem tio nem primos",t->info);
 } //if
 else{
 if(y->fe!=NULL){
 printf("\n\n\t\t %d eh tio de %d",y->fe->info,t->info);
 if(y->fe->fd!=NULL)
 printf("\n\n\t\t %d eh primo de %d",y->fe->fd->info,t->info);
 if(y->fe->fe!=NULL)
 printf("\n\n\t\t %d eh primo de %d",y->fe->fe->info,t->info);
 }//if
 else printf("\n\n\t\t %d nao tem tio nem primos",t->info);
 }//else
 }//if
 }//if
 else printf("\n\n\t\t %d nao tem avo, logo nao tem tio nem primos \n\n\t\t nao tem pai, logo nao tem irmao nem sobrinhos",t->info);
 }
 }//else
 getchar();
}
//_______________________________ EXCLUIR ______________________________________
struct arvore *excluir(struct arvore *t,int x){
 int achou=0;
 if(t!=NULL){ //quando existe elementos na arvore
 while(t->info!=x){
 p=t;
 if(x<t->info)
 t=t->fe;
 else t=t->fd;
 if(t==NULL){ //o numero que se que excluir nao existe
 printf("\n\n\t\t numero inexistente");
 getchar();
 achou=1;
 break;
 }
 }//while
 if(achou!=1){ //o numero existe
 if(t->fe==NULL&&t->fd==NULL){ //o no a excluir é folha
 if(p->fe==t) //o no esta a esquerda de p
 p->fe=NULL;
 else p->fd=NULL; //o no esta a direita de p
 free(t); //exclui-se t
 }
 else if(t->fe==NULL&&t->fd!=NULL){ //o no t tem subarvore a esquerda, mas nao a direita
 if(p->fe==t)
 p->fe=t->fd;
 else p->fd=t->fd;
 free(t);
 }
 else if(t->fe!=NULL&&t->fd==NULL){ //o no t tem subarvore a esquerda, mas nao a direita
 if(p==NULL){
 if(t==raiz)
 raiz=t->fe; //verifica se eh a raiz
 else if(t==raizd)
 raizd=t->fe;
 }
 if(p->fe==t)
 p->fe=t->fe;
 else p->fd=t->fe;
 free(t);
 }
 else{ //o no t tem subarvore a esquerda e a direita
 y=t->fd;
 while(y->fe!=NULL){
 z=y;
 y=y->fe;
 }
 if(z!=NULL)
 z->fe=y->fd;
 t->info=y->info;
 free(y);
 }
 printf("\n\n\t\t No Excluido com Sucesso!!!");
 getchar();
 }//if
 }//if
 else printf("\n\n\t\t arvore vazia");
 getchar();
}
//_______________________________ MAIN _________________________________________
main(){
 int opc,numero;
 raiz=NULL;
 raizd=NULL;
 tree=init(tree); //primeiramente a árvore é inicializada com um valor nulo
 treed=init(treed);
 do{
 limpa();
 printf("\n\n\t\t\t *** ARVORE BINARIA ***");
 printf("\n\n\t\t\t____________________________________");
 printf("\n\t\t\t* [1] INSERIR ORDENADA *");
 printf("\n\t\t\t* [2] INSERIR DIRETA *");
 printf("\n\t\t\t* [3] LISTAR ORDENADA *");
 printf("\n\t\t\t* [4] LISTAR DIRETA *");
 printf("\n\t\t\t* [5] LISTAR EM ORDEM ORDENADA *");
 printf("\n\t\t\t* [6] LISTAR EM ORDEM DIRETA *");
 printf("\n\t\t\t* [7] LISTAR EM PRE ORDEM ORDENADA *");
 printf("\n\t\t\t* [8] LISTAR EM PRE ORDEM DIRETA *");
 printf("\n\t\t\t* [9] LISTAR EM POS ORDEM ORDENADA *");
 printf("\n\t\t\t* [10] LISTAR EM POS ORDEM DIRETA *");
 printf("\n\t\t\t* [11] CLASSIFICAR ARVORE ORDENADA *");
 printf("\n\t\t\t* [12] CLASSIFICAR ARVORE DIRETA *");
 printf("\n\t\t\t* [13] FAMILIARIDADE ORDENADA *");
 printf("\n\t\t\t* [14] FAMILIARIDADE DIRETA *");
 printf("\n\t\t\t* [15] BALANCEAR ORDENADA *");
 printf("\n\t\t\t* [16] NUMERACAO ORDENADA *");
 printf("\n\t\t\t* [17] NUMERACAO DIRETA *");
 printf("\n\t\t\t* [18] EXCLUIR ORDENADA *");
 printf("\n\t\t\t* [19] EXCLUIR DIRETA *");
 printf("\n\t\t\t* [20] SAIR *");
 printf("\n\t\t\t____________________________________");
 printf("\n\t\t\t\t\t OPCAO[ ]\b\b");
 scanf("%d",&opc);
 if(opc<1||opc>20)continue;
 limpa();
 switch(opc){
 case 1:
 entrar_valores(); //nesta função enta-se com os valores a serem inseridos
 getchar(); //e os transfere a função inserir
break;
 case 2:
 entrar_valores_balanceado();
 getchar();
 break;
 case 3:
 if(raiz==NULL){ //se a árvore estiver vazia não é necessário executar
 printf("\n\n\t\t Arvore vazia"); //a função listar
 getchar();
 }
 else{
 printf("\n\n\t\t *** Listar ***\n");
 listar(tree); //caso contrário chama-se então a função listar
 getchar();
	 break;
 }
 case 4:
 if(raizd==NULL){ //se a árvore estiver vazia não é necessário executar
 printf("\n\n\t\t Arvore vazia"); //a função listar
 getchar();
 }
 else{
 printf("\n\n\t\t *** Listar Balanceado ***\n");
 listar_direto(treed);
 getchar();
 break;
 }
 case 5:
 printf("\n\n\t\t *** Listar Em Ordem ***\n");
 listar_em_ordem(tree);
 getchar();
 break;
 case 6:
 printf("\n\n\t\t *** Listar Em Ordem ***\n");
 listar_em_ordem(treed);
 getchar();
 break;
 case 7:
 printf("\n\n\t\t *** Listar Em Pre Ordem ***\n");
 listar_em_pre_ordem(tree);
 getchar();
 break;
 case 8:
 printf("\n\n\t\t *** Listar Em Pre Ordem ***\n");
 listar_em_pre_ordem(treed);
 getchar();
 break;
 case 9:
 printf("\n\n\t\t *** Listar Em Pos Ordem ***\n");
 listar_em_pos_ordem(tree);
 getchar();
 break;
 case 10:
 printf("\n\n\t\t *** Listar Em Pos Ordem ***\n");
 listar_em_pos_ordem(treed);
 getchar();
 break;
 case 11:
 printf("\n\n\t\t *** Classificacao da Arvore ***\n");
 verifica_classificacao();
 getchar();
 break;
 case 12:
 printf("\n\n\t\t *** Classificacao da Arvore ***\n");
 verifica_classificacao();
 getchar();
 break;
 case 13:
 if(tree==NULL)
 printf("\n\n\t\t Arvore Vazia");
 else{
 y=NULL;
 p=NULL; //atualiza o ponteiro p e y
 printf("\n\n\t\t Digite o No a Buscar: ");
 scanf("%d",&numero);
 familiaridade(tree,numero,0);
 getchar();
 break;
 }
 case 14:
 if(treed==NULL)
 printf("\n\n\t\t Arvore Vazia");
 else{
 y=NULL;
 p=NULL; //atualiza o ponteiro p e y
 printf("\n\n\t\t Digite o No a Buscar: ");
 scanf("%d",&numero);
 familiaridade(treed,numero,0);
 getchar();
 break;
 }
 case 15:
 tree=verifica_balanceamento(tree);
 printf("\n\n\t\t Arvore Balanceada!!!");
 getchar();
 break;
 case 16:
 maior_nivel=0;
 num_nos=0;
 inicializa_vet();
 contar_nos(tree,0);
 numeracao(tree,0); 
	 getchar();
	 getchar();
 break;
 case 17:
 maior_nivel=0;
 num_nos=0;
 inicializa_vet();
 contar_nos(treed,0);
 numeracao(treed,0);
	 getchar();
	 getchar();
 break;
 case 18:
 y=NULL;
 p=NULL; //atualiza o ponteiro p e y
 printf("\n\n\t\t digite o numero a excluir: ");
 scanf("%d",&numero);
 excluir(tree,numero);
 getchar();
 break;
 case 19:
 y=NULL;
 p=NULL; //atualiza o ponteiro p e y
 printf("\n\n\t\t digite o numero a excluir: ");
 scanf("%d",&numero);
 excluir(treed,numero);
 getchar();
 break;
 }
 }while(opc!=20); //executa o do/while enquanto a opção sair não for selecionada
 getchar();
}