C Arvore Binária com string

[NivaldoReis]

Onde estou errando aqui ?
 

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

struct no
{
    char chave[15];
    struct no*esquerda;
    struct no*direita;
    struct no*pai;
};
typedef struct no No;
No* criar_no(char c)
    return 0;
}
{
    No* novo = (No*) malloc(sizeof(No) );
    novo->chave =c;
    novo->pai = NULL;
    novo->esquerda = NULL;
    novo->direita = NULL;

    return novo;
}
int main()
{

 

[Simon Viegas]

9 horas atrás, NivaldoReis disse:

Onde estou errando aqui ?

 

Depende.

 

O que está acontecendo de errado?

Qual o enunciado do problema?

 

 

[NivaldoReis]

oi amigo , se poderá me ajudar ?

[Gabriel_Moro]

Em 14/12/2018 às 00:23, NivaldoReis disse:

novo->chave =c;

use strcpy para strings

[NivaldoReis]

Boa noite, se pode me ajudar ai , eu estou fazendo esta disciplina pela terceira vez, já fiz matérias até do 6 periodo, quarto e quinto , estou travando nesta dai .

[Gabriel_Moro]

fale suas duvidas...

a disciplina é estrutura de dados?

suas duvidas são só em árvores?

[NivaldoReis]

isto mesmo, as ordenações eu entendi Bubble Sort, Selection Sort e Quick Sort. Estou apanhando é ai .

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

struct no
{
    char chave[20];
    struct no *pai;
    struct no *esquerda;
    struct no *direita;
};

typedef struct no No;

No* criar_no(char c)
{
No* novo = (No*) malloc(sizeof(No) );
novo->chave[20] = c;
novo->pai = NULL;
novo->esquerda = NULL;
novo->direita = NULL;
return novo;
}

void inserir(No *raiz,No *novo)
{
printf("%s", novo->chave);
No *y=NULL;
No *aux=y;

while(y!=NULL)
{
    aux=y;
    if(strcmp(y->chave,novo->chave)<0)
        y=y->esquerda;
    else if(y->chave, novo->chave >0)
        y= y->direita;

}
if(strcmp(y->chave, novo->chave)<0)
    aux->esquerda = novo;
else if(strcmp(aux->chave, novo->chave)>0)
    aux->direita= novo;
}

void deletar(No *raiz, No *novo)
{
No *y=NULL;
if(strcmp(y->esquerda==NULL || y->direita==NULL))
    y=novo;
}

int main()
{

return 0;
}

 

[Gabriel_Moro]

 

https://www.youtube.com/watch?v=iLvpaqAoVD8&list=PL8iN9FQ7_jt7LwqmdiyhVVu2J4jQQ9uRW

 

como esta seu entendimento dos conceitos básicos de árvores? no papel consegue construir uma árvore, e fazer operações do tipo remover, mostrar pre-ordem - pós-ordem - in-ordem?

[Simon Viegas]

@NivaldoReis.

 

Qual o enunciado do problema?

Está com dúvida em qual parte?

[Gabriel_Moro]

implemente usando recurção, se torna mais simples

[NivaldoReis]

Ele passou 

 

adicionado 1 minuto depois

@Gabriel_Moro tenho aqui, o modelo de código que ele fez baseado.

 

Código abaixo:

 

arvore.h:

/* Definicao do TAD ARvore Binaria
 ** Tipo No
 ** Tipo Arvore (Opcional)
*/
typedef struct no No;

//typedef struct arvore Arvore;
/* Aloca espaço para um no da Arvore */
No* criar_no(char c);
/* Liberar espaço do no da Arvore */
void liberar_no(No* x);
/* Atribui um valor de chave para o no*/
void atribuir_chave(No* x, char c);
/* Atribui um filho a esquerda do no*/
void atribuir_filho_esquerda(No* x, No* esq);
/* Atribui um filho a direita do no*/
void atribuir_filho_direita(No* x, No* dir);
/* Atribui o pai do no*/
void atribuir_pai(No* x, No* p);

/* Obter o valor da chave do no*/
char chave(No* x);
/* Obter o filho a esquerda do no*/
No* filho_esquerda(No* x);
/* Obter o filho a direita do no*/
No* filho_direita(No* x);
/* Obter o pai do no*/
No* pai(No* x);

/* Imprime o valor da chave do no */
void visitar(No* x);
/* Imprime uma linha com o valor da chave do nó e o valor da chave do filho da esquerda e da direita */
void detalhar(No* x);
/* Percorre a arvore, visitando cada no */
void listar_arvore(No* raiz);

 

arvore.c:

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

struct no
{
	char chave;
	struct no* esquerda;
	struct no* direita;
	struct no* pai;
};

void visitar(No* x)
{
	printf("%c\n", x->chave);
}

void detalhar(No* x)
{
	printf("%c;", x->chave);
	if(x->esquerda != NULL)
		printf("<- %c;", x->esquerda->chave);
	else
		printf("<- NULL;");

	if(x->direita != NULL)
		printf("<- %c;", x->direita->chave);
	else
		printf("<- NULL;");
	printf("\n");
}

No* criar_no(char c)
{
	No* novo = (No*) malloc(sizeof(No) );
	novo->chave = c;
	novo->pai = NULL;
	novo->esquerda = NULL;
	novo->direita = NULL;

	return novo;
}

void liberar_no(No* x)
{
	free(x);
}

void atribuir_chave(No* x, char c)
{
	if(x != NULL)
		x->chave = c;
}

void atribuir_filho_esquerda(No* x, No* esq)
{
	if(x != NULL)
	{
		x->esquerda = esq;
		esq->pai = x;
	}
}

void atribuir_filho_direita(No* x, No* dir)
{
	if(x != NULL)
	{
		x->direita = dir;
		dir->pai = x;
	}
}

void atribuir_pai(No* x, No* p)
{
	if(x != NULL)
		x->pai = p;
}

char chave(No* x)
{
	if(x != NULL)
		return x->chave;
}

No* filho_esquerda(No* x)
{
	if(x != NULL)
		return x->esquerda;
}

No* filho_direita(No* x)
{
	if(x != NULL)
		return x->direita;
}

No* pai(No* x)
{
	if(x != NULL)
		return x->pai;
}

 

Exercicios-Aula10.c:

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

int main()
{
	No* raiz;
	No* aux;

	//criar raiz da arvore
	raiz = criar_no('A');
	atribuir_pai(raiz, NULL);
	//criar filho da esquerda da raiz
	aux = criar_no('B');
	atribuir_filho_esquerda(raiz, aux);
	//criar filho da direita da raiz
	aux = criar_no('C');
	atribuir_filho_direita(raiz, aux);
	//criar filho da esquerda do no 'C'
	aux = criar_no('D');
	atribuir_filho_esquerda( filho_direita(raiz), aux);
	//criar filho da direita do no 'C'
	aux = criar_no('E');
	atribuir_filho_direita( filho_direita(raiz), aux);


	detalhar(raiz);
	detalhar( filho_esquerda(raiz) );
	detalhar( filho_direita(raiz) );
	aux = filho_esquerda( filho_direita(raiz) );
	detalhar(aux);
	aux = filho_direita( filho_direita(raiz) );
	detalhar(aux);

	return 0;
}

 

Pacote com os arquivos: 2018-11-08_20-46-26_TAD-Arvore-Binaria.rar

[Gabriel_Moro]

vi esse exemplo e achei bem pobre

void insereNodo(struct nodoArv * atual, struct nodoArv * novo) {
	if (novo->info < atual->info) {
		if (atual->esq == NULL) {
			atual->esq = novo;
			atual->esq->pai = atual; //seta o pai
		} else
			insereNodo(atual->esq, novo);
	} else {
		if (atual->dir == NULL) {
			atual->dir = novo;
			atual->dir->pai = atual;
		} else
			insereNodo(atual->dir, novo);
	}
}
void insere(int dado) {
	struct nodoArv * novo;
	novo = (struct nodoArv *) malloc(sizeof(elemento));
	novo->info = dado;
	novo->esq = NULL;
	novo->dir = NULL;
	novo->pai = NULL;

	if (raiz == NULL)
		raiz = novo;
	else
		insereNodo(raiz, novo);
}

te passei um exemplo de inserção

tente implementar funções para mostrar in-order pre-order e pos-order

utilize sempre recurção

[NivaldoReis]

Me fala uma coisa , primeiro eu tenho que criar o nó , depois que eu faço a inserção ?

[Gabriel_Moro]

sim

10 minutos atrás, Gabriel_Moro disse:

struct nodoArv * novo; 
novo = (struct nodoArv *) malloc(sizeof(elemento)); 
novo->info = dado; 
novo->esq = NULL; 
novo->dir = NULL; 
novo->pai = NULL;

criação

 

10 minutos atrás, Gabriel_Moro disse:

if (raiz == NULL) 
    raiz = novo; 
else 
    insereNodo(raiz, novo);

inserção

[NivaldoReis]

Estava tentando fazer igual o pseudocódigo ai .

2018-10-26_15-08-29_Aula10.rar

adicionado 11 minutos depois

Achei algo aqui no livro , será que assim ficaria legal ?

struct arv
{
    char info;
    struct arv*esq;
    struct arv*dir;
};
typedef struct arv Arv;

Arv*arv_criavazia(void)
{
    return NULL;
}
Arv* arv_cria(char c, Arv*sae, Arv* sad)
{
    Arv* p=(Arv*) malloc(sizeof(Arv));
    p->info=c;
    p->esq=sae;
    p->dir=sad;
    return p;
}

 

[Gabriel_Moro]

pelo que vi na descrição deseja-se saber as detalhes das operações

 

24 minutos atrás, Gabriel_Moro disse:

if (atual->esq == NULL) { 
    atual->esq = novo; 
    atual->esq->pai = atual; //seta o pai 
    printf("inserido a esquerda de %d\n", atual->info);// isso é um detalhe
} else 
    insereNodo(atual->esq, novo);

 

[NivaldoReis]

Você tem hangout ?

[Gabriel_Moro]

não

https://discord.gg/PRUvCE

[NivaldoReis]

entrei la

[NivaldoReis]

Olá amigo , eu tentei fazer aqui , mas eu não saio do lugar , se você puder me ajudar , ficarei grato .

[Simon Viegas]

Poste o que já fez e onde está com dúvidas.