C Arvore Binária String Não Imprime Dados

Cristian Leoncini · 14 de maio de 2020

Bom dia! Estou com um projeto de uma agenda em arvore binária, onde eu armazeno o nome, email, endereço, data de aniversário e idade. A inserção dos dados esta funcionando, mas quando eu mando ele imprimir em uma outra função o programa trava.

Meu código:

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

struct arvore{
	
	char nome[100];
	char email[100];
	char endereco[250];
	char dataAniversario[10];
	int idade;
	struct arvore *esq;
	struct arvore *dir;
	
};

typedef struct arvore arv;

arv* insere(arv *raiz, arv arvoree){
	
	int i=0;
	arv *a;
	
	if(i==NULL){
		
		a=(arv*)malloc(sizeof(arv));
		strcpy(a->nome,arvoree.nome);
		strcpy(a->email,arvoree.email);
		strcpy(a->endereco,arvoree.endereco);
		strcpy(a->dataAniversario,arvoree.dataAniversario);
		a->idade=arvoree.idade;
		a->esq=NULL;
		a->dir=NULL;
		
	}else if(strcmp(raiz->nome,arvoree.nome) > 0){
		
		a->esq = insere(raiz->esq, arvoree);
		
	}else{
		
		a->dir = insere(raiz->dir, arvoree);
		
	}
	
	i++;
	
	return a;
	
}



void imprimePreOrdem(arv* raiz){
	
	printf("\nNome: %s\n", raiz->nome);
	printf("Email: %s\n", raiz->email);
	printf("Endereco: %s\n", raiz->endereco);
	printf("Aniversario: %s\n", raiz->dataAniversario);
	printf("Idade: %i anos\n\n\n", raiz->idade);
	imprimePreOrdem(raiz->esq);
	imprimePreOrdem(raiz->dir);	
	
}

void imprimeEmOrdem(arv* raiz){
	
	imprimeEmOrdem(raiz->esq);
	printf("\nNome: %s\n", raiz->nome);
	printf("Email: %s\n", raiz->email);
	printf("Endereco: %s\n", raiz->endereco);
	printf("Aniversario: %s\n", raiz->dataAniversario);
	printf("Idade: %i anos\n\n\n", raiz->idade);
	imprimeEmOrdem(raiz->dir);	
	
}

void imprimePosOrdem(arv* raiz){
	
	imprimePosOrdem(raiz->esq);
	imprimePosOrdem(raiz->dir);	
	printf("\nNome: %s\n", raiz->nome);
	printf("Email: %s\n", raiz->email);
	printf("Endereco: %s\n", raiz->endereco);
	printf("Aniversario: %s\n", raiz->dataAniversario);
	printf("Idade: %i anos\n\n\n", raiz->idade);
	
}

void imprimir(arv* raiz){
	
	int escolha=0;
	printf("[1]Listar todos os dados em pre ordem\n[2]Listar todos os dados em ordem\n[3]Listar todos os dados em pos ordem\n");
	scanf("%i", &escolha);
	
	if(escolha==1){
		
		imprimePreOrdem(raiz);
		
	}else if(escolha==2){
		
		imprimeEmOrdem(raiz);
		
	}else if(escolha==3){
		
		imprimePosOrdem(raiz);
		
	}
	
}

int main(){

arv arvoree;
arv *raiz;
int opcao;

printf("\n[1]Inserir\n[2]Buscar\n[3]Listar todos os dados\n[4]Sair\n");
scanf("%i", &opcao);
getchar();
system("cls");

while(opcao!=NULL){

switch(opcao){
	
	case 1:{
		
		printf("\nInsira o nome:\n");
		gets(arvoree.nome);
		system("cls");
		printf("\nInsira o email:\n");
		gets(arvoree.email);
		system("cls");
		printf("\nInsira o endereco:\n");
		gets(arvoree.endereco);
		system("cls");
		printf("\nInsira a data de aniversario:\n");
		gets(arvoree.dataAniversario);
		system("cls");
		printf("\nInsira a idade:\n");
		scanf("%i", &arvoree.idade);
		system("cls");
		raiz=insere(raiz, arvoree);
		
		return main();
		
		break;
	}
	
	case 2:{
		
		
		
		break;
	}
	
	case 3:{
		
		imprimir(raiz);
		
		return main();
		
		break;
	}
	
	case 4:{
		
		exit(0);
		
		break;
	}
	
	
}

}

}

Ansi C · 14 de maio de 2020

Acesso recursivo além do limite da arvore.

46 minutos atrás, Cristian Leoncini disse:
void imprimePosOrdem(arv* raiz){
	 imprimePosOrdem(raiz->esq);
...

.Nunca para, melhor para com explosão de acesso violado a memoria

Ps.: antes passou o ponteiro NULL

Cristian Leoncini · 14 de maio de 2020

@Mauro Britivaldo eu dei uma mudada no código mas continua com o mesmo problema

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

struct arvore{
	
	char nome[100];
	char email[100];
	char endereco[250];
	char dataAniversario[10];
	int idade;
	struct arvore *esq;
	struct arvore *dir;
	
};

typedef struct arvore arv;

arv* insere(arv *raiz, arv arvoree){
	
	int i=0;
	arv *a;
	
	if(i==NULL){
		
		a=(arv*)malloc(sizeof(arv));
		strcpy(a->nome,arvoree.nome);
		strcpy(a->email,arvoree.email);
		strcpy(a->endereco,arvoree.endereco);
		strcpy(a->dataAniversario,arvoree.dataAniversario);
		a->idade=arvoree.idade;
		a->esq=NULL;
		a->dir=NULL;
		
	}else if(strcmp(raiz->nome,arvoree.nome) > 0){
		
		a->esq = insere(raiz->esq, arvoree);
		
	}else{
		
		a->dir = insere(raiz->dir, arvoree);
		
	}
	
	i++;
	
	return a;
	
}



void imprimePreOrdem(arv* raiz){
	
	if(raiz!=NULL){
	
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
		imprimePreOrdem(raiz->esq);
		imprimePreOrdem(raiz->dir);	
	
	}
	
}

void imprimeEmOrdem(arv* raiz){
	
	if(raiz!=NULL){
	
		imprimeEmOrdem(raiz->esq);
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
		imprimeEmOrdem(raiz->dir);	
	
	}
	
}

void imprimePosOrdem(arv* raiz){
	
	if(raiz!=NULL){
	
		imprimePosOrdem(raiz->esq);
		imprimePosOrdem(raiz->dir);	
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
	
	}
	
}

void imprimir(arv* raiz){
	
	int escolha=0;
	printf("[1]Listar todos os dados em pre ordem\n[2]Listar todos os dados em ordem\n[3]Listar todos os dados em pos ordem\n");
	scanf("%i", &escolha);
	
	if(escolha==1){
		
		imprimePreOrdem(raiz);
		system("PAUSE");
		
	}else if(escolha==2){
		
		imprimeEmOrdem(raiz);
		system("PAUSE");
		
	}else if(escolha==3){
		
		imprimePosOrdem(raiz);
		system("PAUSE");
		
	}
	
}

void busca(arv nomeBusca,  arv* raiz){
	
	printf("\nInsira o nome de busca:\n");
	gets(nomeBusca.nome);
	
	if(strcmp(nomeBusca.nome, raiz->nome) == 0){
		
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
		
	}else{
		
		printf("\n\nPessoa nao encontrada\n\n");
		system("PAUSE");
		
	}
	
	busca(nomeBusca, raiz->esq);
	busca(nomeBusca, raiz->dir);
	
}

int main(){

arv arvoree;
arv *raiz;
arv nomeBusca;
int opcao;

printf("\n\n[1]Inserir\n[2]Buscar\n[3]Listar todos os dados\n[4]Sair\n");
scanf("%i", &opcao);
getchar();
system("cls");

while(opcao!=NULL){

switch(opcao){
	
	case 1:{
		
		printf("\nInsira o nome:\n");
		gets(arvoree.nome);
		system("cls");
		printf("\nInsira o email:\n");
		gets(arvoree.email);
		system("cls");
		printf("\nInsira o endereco:\n");
		gets(arvoree.endereco);
		system("cls");
		printf("\nInsira a data de aniversario:\n");
		gets(arvoree.dataAniversario);
		system("cls");
		printf("\nInsira a idade:\n");
		scanf("%i", &arvoree.idade);
		system("cls");
		raiz=insere(raiz, arvoree);
		
		return main();
		
		break;
	}
	
	case 2:{
		
		busca(nomeBusca, raiz);
		
		system("PAUSE");
		return main();
		
		break;
	}
	
	case 3:{
		
		imprimir(raiz);
		
		return main();
		
		break;
	}
	
	case 4:{
		
		exit(0);
		
		break;
	}
	
	
}

}

}

Ansi C · 14 de maio de 2020

void imprimePreOrdem(arv* raiz){
	if(raiz != NULL)
	{
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
      
		imprimePreOrdem(raiz->esq); 
      
		imprimePreOrdem(raiz->dir);
    }
}

Por mais inusitada que é pra mim, eu ainda acredito nesse lógica.

Entretanto, será que não estamos os dois errados. Seu algoritmo é fundamentado na recursividade e com isso vem muitas falhas, principalmente as de pilha de funções que é limitada.

arfneto · 14 de maio de 2020


arv* insere(arv* raiz, arv arvoree) {

	int i = 0;
	arv* a;

	if (i == NULL) {

		a = (arv*)malloc(sizeof(arv));
		strcpy(a->nome, arvoree.nome);
		strcpy(a->email, arvoree.email);
		strcpy(a->endereco, arvoree.endereco);
		strcpy(a->dataAniversario, arvoree.dataAniversario);
		a->idade = arvoree.idade;
		a->esq = NULL;
		a->dir = NULL;

Não tive tempo ainda de olhar o seu programa, vou ver daqui 1h ou duas.

Uma coisa que posso dizer agora é que essa maneira de escrever é muito arriscada para desenvolver e testar. E lerda. E nada produtiva na hora de usar.

Isso também


void busca(arv nomeBusca, arv* raiz) {

	printf("\nInsira o nome de busca:\n");
	gets(nomeBusca.nome);

	if (strcmp(nomeBusca.nome, raiz->nome) == 0) {

		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);

	}
	else {

E declarar assim

struct arvore {
	char nome[100];
	char email[100];
	char endereco[250];
	char dataAniversario[10];
	int idade;
	struct arvore* esq;
	struct arvore* dir;
};

Prefira sempre algo assim por exemplo:

struct _carga
{
	char    nome[100];
	char    email[100];
	char    endereco[250];
	char    dataAniversario[10];
	int     idade;
};
typedef struct _Carga Carga;

struct _arvore
{
	Carga*      dados;
	Arvore*     L;
	Arvore*     R;

};
typedef struct _arvore Arvore;

Arvore* insere(Carga* dados, Arvore* arvore);
Arvore* preOrder(Arvore* arvore);
Arvore* inOrder(Arvore* arvore);
Arvore* postOrder(Arvore* arvore);

A razão:

a tal struct Carga, que tem os dados, pode ser qualquer coisa. Em geral se declara mesmo como (void*). E você não usa mexe mais nisso a menos que ache um erro.
O percurso pode receber um suposto endereço de arvore e ir devolvendo os nós conforme passa e aí você imprime. Você não imprime dentro da rotina de percurso, pelo mesmo motivo: percorrer a árvore é sempre igual. Você pode ter várias delas em seu programa.
Você escreve isso, testa, coloca em um arquivo arvore.c e escreve um header arvore.h e nunca mais mexe nisso. Do modo como escreveu, e que é o normal, você resolve no máximo um problema. E demora.

adicionado 17 minutos depois

@Cristian Leoncini que pretende com essa variável i ? Podia comentar seu código um pouco.

Se está contando com ela nas outras chamadas você tem um problema aí... O que era pra ser isso?

Você precisa mesmo usar uma árvore para isso? Uma lista parece mais prático. Trata-se de um enunciado?

arfneto · 18 de maio de 2020

arv* insere(arv* raiz, arv arvoree)
{
	int i = 0;
	arv* a;

	if (i == NULL) {

		a = (arv*)malloc(sizeof(arv));
		strcpy(a->nome, arvoree.nome);
		strcpy(a->email, arvoree.email);
		strcpy(a->endereco, arvoree.endereco);
		strcpy(a->dataAniversario, arvoree.dataAniversario);
		a->idade = arvoree.idade;
		a->esq = NULL;
		a->dir = NULL;

Continua valendo tudo que eu escrevi, mas acho que ficou meio escondido isso no texto:

Citação

O que pretende com essa variável i?

Acabou de declarar como i = 0 e em seguida testa se é igual a NULL, que é... ZERO.

void imprimePreOrdem(arv* raiz){
	if(raiz != NULL)
	{
		printf("\nNome: %s\n", raiz->nome);
		printf("Email: %s\n", raiz->email);
		printf("Endereco: %s\n", raiz->endereco);
		printf("Aniversario: %s\n", raiz->dataAniversario);
		printf("Idade: %i anos\n\n\n", raiz->idade);
      
		imprimePreOrdem(raiz->esq); 
      
		imprimePreOrdem(raiz->dir);
    }
}

Em 14/05/2020 às 17:09, Mauro Britivaldo disse:

Por mais inusitada que é pra mim, eu ainda acredito nesse lógica.

Não é assim inusitado. É apenas o comum. Nada original.

Veja por exemplo em https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal_in_c.htm
que

Bem familiar não é. Não precisa nem abrir o site pra copiar o código Mas não é o caso de copiar. É a definição mesmo: Em preOrder você "visita" o nó na primeira vez que o vê e depois continua percorrendo a árvore, sempre começando pela esquerda.

Em 14/05/2020 às 17:09, Mauro Britivaldo disse:

Entretanto, será que não estamos os dois errados. Seu algoritmo é fundamentado na recursividade e com isso vem muitas falhas, principalmente as de pilha de funções que é limitada

Não vem com muitas falhas. Considere que a recursão ocorre uma vez para cada nível. Com uma árvore binária como essa uma árvore de apenas 10 níveis já pode ter até 2^10 - 1 = 1023 elementos. Seria preciso uma entrada bem especial, algo como entrar com valores em ordem decrescente para cair no pior caso e deixar apenas um nó para cada nível para ter uma situação mais preocupante.

Mas é válida a preocupação. E por isso em geral se tenta usar árvores balanceadas automaticamente para ir distribuindo os nós mais arrumadinhos para os dois lados em relação à raiz. Basicamente se faz isso usando rotação dos nós e mudando a raiz quando preciso, e mantendo a árvore "equilibrada".

Ansi C · 18 de maio de 2020

Recursividade não nem um pouco usual. #SaiFora

Mas ainda acredito nesse algoritmo.

.

arfneto · 18 de maio de 2020

27 minutos atrás, Mauro Britivaldo disse:

Recursividade não nem um pouco usual. #SaiFora

Mas ainda acredito nesse algoritmo.

.

Esse algoritmo é a implementação comum, como te mostrei. Apenas a transcrição da definição. No caso dos 3 métodos. Só muda o ponto da "visita", no caso aqui o momento onde imprime o nó.

Veja um exemplo de código para os 3 tipos de percurso, em C, direto de https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal_in_c.htm

void pre_order_traversal(struct node* root) {
   if(root != NULL) {
      printf("%d ",root->data);
      pre_order_traversal(root->leftChild);
      pre_order_traversal(root->rightChild);
   }
}

void inorder_traversal(struct node* root) {
   if(root != NULL) {
      inorder_traversal(root->leftChild);
      printf("%d ",root->data);          
      inorder_traversal(root->rightChild);
   }
}

void post_order_traversal(struct node* root) {
   if(root != NULL) {
      post_order_traversal(root->leftChild);
      post_order_traversal(root->rightChild);
      printf("%d ", root->data);
   }
}

Se acha que em seu cenário pode atingir mesmo algum caso limite e não quer usar recursão pode implementar todos os 3 usando uma pilha para controlar o percurso na volta. Não é complicado.

O que importa para o aluno considerar é que:

o inOrder trás os elementos em ordem crescente numa árvore binária.
PostOrder visita os nós a partir "do fundo" e é a maneira segura de você apagar a estrutura ao final do programa, porque uma vez que você visitou o nó não vai mais passar por ele então pode chamar free()
O percurso por nível é o que traz os elementos em ordem.

Ansi C · 18 de maio de 2020

Eu já entendi tudo isso, pare de ser "recursivo", por favor.

E reforço o não uso de recursividade.

Cristian Leoncini · 19 de maio de 2020

@arfneto Estou fazendo assim por ser um trabalho de faculdade, e o professor pede que seja arvore binária

arfneto · 19 de maio de 2020

Entendeu as coisas que te expliquei, em especial sobre a função insere()?

Alterou o programa?

Como está agora?

Cristian Leoncini · 19 de maio de 2020

@arfneto entendi sim, obrigado, agora o programa está tudo certinho, só a função de busca está dando erro

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

struct arvore
{

    char nome[100];
    char email[100];
    char endereco[250];
    char dataAniversario[10];
    int idade;
    struct arvore *esq;
    struct arvore *dir;
};

typedef struct arvore arv;

arv *insere(arv *raiz, arv arvoree)
{

    arv *a;

    if (raiz == NULL)
    {

        a = (arv *)malloc(sizeof(arv));
        strcpy(a->nome, arvoree.nome);
        strcpy(a->email, arvoree.email);
        strcpy(a->endereco, arvoree.endereco);
        strcpy(a->dataAniversario, arvoree.dataAniversario);
        a->idade = arvoree.idade;
        a->esq = NULL;
        a->dir = NULL;

        return a;
    }
    else if (strcmp(raiz->nome, arvoree.nome) > 0)
    {

        printf("Batata");
        raiz->dir = insere(raiz->dir, arvoree);
    }
    else
    {

        printf("ola");
        raiz->esq = insere(raiz->esq, arvoree);
    }

    return raiz;
}

void imprimePreOrdem(arv *raiz)
{

    if (raiz != NULL)
    {

        printf("\nNome: %s\n", raiz->nome);
        printf("Email: %s\n", raiz->email);
        printf("Endereco: %s\n", raiz->endereco);
        printf("Aniversario: %s\n", raiz->dataAniversario);
        printf("Idade: %i anos\n\n\n", raiz->idade);
        imprimePreOrdem(raiz->esq);
        imprimePreOrdem(raiz->dir);
    }
}

void imprimeEmOrdem(arv *raiz)
{

    if (raiz != NULL)
    {

        imprimeEmOrdem(raiz->esq);
        printf("\nNome: %s\n", raiz->nome);
        printf("Email: %s\n", raiz->email);
        printf("Endereco: %s\n", raiz->endereco);
        printf("Aniversario: %s\n", raiz->dataAniversario);
        printf("Idade: %i anos\n\n\n", raiz->idade);
        imprimeEmOrdem(raiz->dir);
    }
}

void imprimePosOrdem(arv *raiz)
{

    if (raiz != NULL)
    {

        imprimePosOrdem(raiz->esq);
        imprimePosOrdem(raiz->dir);
        printf("\nNome: %s\n", raiz->nome);
        printf("Email: %s\n", raiz->email);
        printf("Endereco: %s\n", raiz->endereco);
        printf("Aniversario: %s\n", raiz->dataAniversario);
        printf("Idade: %i anos\n\n\n", raiz->idade);
    }
}

void imprimir(arv *raiz)
{

    int escolha = 0;
    printf("[1]Listar todos os dados em pre ordem\n[2]Listar todos os dados em ordem\n[3]Listar todos os dados em pos ordem\n");
    scanf("%i", &escolha);

    if (escolha == 1)
    {

        imprimePreOrdem(raiz);
    }
    else if (escolha == 2)
    {

        imprimeEmOrdem(raiz);
    }
    else if (escolha == 3)
    {

        imprimePosOrdem(raiz);
    }
}

void busca(arv nomeBusca, arv *raiz)
{

    printf("\nInsira o nome de busca:\n");
    fgets(nomeBusca.nome, 50, stdin);

    if (strcmp(nomeBusca.nome, raiz->nome) == 0)
    {

        printf("\nNome: %s\n", raiz->nome);
        printf("Email: %s\n", raiz->email);
        printf("Endereco: %s\n", raiz->endereco);
        printf("Aniversario: %s\n", raiz->dataAniversario);
        printf("Idade: %i anos\n\n\n", raiz->idade);
    }
    else
    {

        printf("\n\nPessoa nao encontrada\n\n");
        
    }

    busca(nomeBusca, raiz->esq);
    busca(nomeBusca, raiz->dir);
    
}

int main()
{

    arv arvoree;
    arv *raiz = NULL;
    arv nomeBusca;
    int opcao;
    int a = 1;

    
    while (a == 1)
    {
        printf("\n\n[1]Inserir\n[2]Buscar\n[3]Listar todos os dados\n[4]Sair\n");
    scanf("%i", &opcao);
        switch (opcao)
        {

        case 1:
        {
                 getchar();
   
            printf("\nInsira o nome:\n");
            fgets(arvoree.nome, 50, stdin);
            printf("\nInsira o email:\n");
            fgets(arvoree.email, 50, stdin);
            printf("\nInsira o endereco:\n");
            fgets(arvoree.endereco, 50, stdin);
            printf("\nInsira a data de aniversario:\n");
            fgets(arvoree.dataAniversario, 50, stdin);
            printf("\nInsira a idade:\n");
            scanf("%i", &arvoree.idade);
            getchar();

            raiz = insere(raiz, arvoree);

            break;
        }

        case 2:
        {

            busca(nomeBusca, raiz);

            system("PAUSE");

            break;
        }

        case 3:
        {

            imprimir(raiz);

            break;
        }

        case 4:
        {

            exit(0);

            break;
        }
        }
    }
}

arfneto · 19 de maio de 2020

Está bem. vou ver se encontro algo

adicionado 53 minutos depois

void busca(arv nomeBusca, arv* raiz)
{
    printf("\nInsira o nome de busca:\n");
    fgets(nomeBusca.nome, 50, stdin);
    if (strcmp(nomeBusca.nome, raiz->nome) == 0)
    {
        printf("\nNome: %s\n", raiz->nome);
        printf("Email: %s\n", raiz->email);
        printf("Endereco: %s\n", raiz->endereco);
        printf("Aniversario: %s\n", raiz->dataAniversario);
        printf("Idade: %i anos\n\n\n", raiz->idade);
    }
    else
    {
        printf("\n\nPessoa nao encontrada\n\n");
    };  // if()
    busca(nomeBusca, raiz->esq);
    busca(nomeBusca, raiz->dir);
};  // busca()

Essa acima é sua função de busca.

Vamos imaginar que uma função de percurso percorre a árvore toda, certo? InOrder, PreOrder, PostOrder, Por Nível, qualquer um. Você escreveu 3 e imagino que tenha testado.

Pergunta

Porque a função de busca não é igualzinho a uma das 3 de percurso, por exemplo a InOrder? Tente achar na função acima onde ela retorna se não acha o cara... Quanto chegar nas folhas sabe quanto vai valer raiz->esq e raiz->dir?

Vai valer zero e cancelar seu programa. É assim com as árvores.


void busca(arv nomeBusca, arv* raiz)
{
    printf("\nInsira o nome de busca:\n");
    fgets(nomeBusca.nome, 50, stdin);
    if (strcmp(nomeBusca.nome, raiz->nome) == 0)

Leu as coisas que te recomendei no meu primeiro post?

Assim não está bom. Não misture leitura de valores ou impressão nas rotinas que manipulam a estrutura de dados.

Sempre dá m#$%a. Não é esperto.

E nesse caso muito menos: se busca começa lendo um valor você não pode testar busca com valores conhecidos para testar seu programa. E como busca() começa lendo e você chama busca() recusrivamente sabe o que vai acontecer? Sim, sabe porque já viu: vai ler de novo....

declare busca assim

    arv* busca(arv* nomeBusca, arv* raiz);

Recebe um endereço e devolve um endereço, ou NULL se não encontrar o cara.

Essa não é uma maneira boa de declarar arvores. Eu te mostrei uma maneira melhor no primeiro post. A maneira oficial, Devia ter alterado. É mais esperto.

Uma opção, de novo:

 struct _arvore
 {
	 _Folha*    raiz;
	 int        niveis;
	 char*      nome;
 };
 typedef struct _arvore _Arvore;

Repare que a árvore tem um nome e um número de níveis que você usa em certos casos. E tem uma "folha" que é a raiz. Só isso.

Uma folha

struct _folha
{
	_Carga*         dados;
	char            saldo;
	struct _folha*  L;
	struct _folha*  P;
	struct _folha*  R;
};
typedef struct _folha _Folha;

Na folha é que estão os ponteiros. Porque? É mais fácil de programar. Tem o ponteiro para o "pai" que pode acelerar muito certas coisas na hora de navegar. Mas você não precisa usar. E tem um tal saldo que é o que a gente usa no caso de tentar balancear a árvore, como aquelas AVL citadas no enunciado. Claro que também não precisa usar.

E os dados?

Pois é: cada folha tem um ponteiro para os dados. Assim você pode usar a mesma árvore para qualquer coisa. É por isso que a gente usa computadores e programa algoritmos afinal: para usar depois..

Veja um possível registro de dados:

struct _carga
{
	char    nome[100];
	char    email[100];
	char    endereco[250];
	char    dataAniversario[11];
	int     idade;
};
typedef struct _carga _Carga;

Sim, o do seu programa.

Mas se na semana que vem seu professor vier com o clássico exercício da playlist ou aquele da biblioteca ou aquele da nota fiscal, você usa A MESMA ARVORE e não precisa nem compilar essa parte...

As mesmas funções de busca, de percurso...

A gente só programa essas estruturas uma vez. Listas, Pilhas, Arvores, Mapas, Dicionários, o que seja.

Tanto que em geral essas coisas estão na biblioteca padrão. Todas. Em java, em Python em C++... Você só programa de novo se não servirem ou se achar um erro