Ir para conteúdo
Fórum Script Brasil
  • 0

Problemas com Arvore

PauloJr

Perguntado por PauloJr,

 Share

Pergunta

PauloJr

PauloJr

Postado
Postado

Estou escrevendo o código abaixo para que o mesmo crie uma arvore, porém estou tendo o seguinte problema, há arvore em si não é criada.

Ele simplesmente não emenda um nó com o outro.

Então peço ajuda dos demais para que me expliquem o por que. por que pelo o que eu consegui encontrar de erro nesse código foi na manipulação de ponteiros.

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

typedef struct Raiz{

    struct Raiz *No_Dir;
    struct Raiz *No_Esq;

    int valor;
}Raiz;

Raiz * Busca(Raiz *Arvore,int valor){
    if(Arvore == NULL)
        return Arvore;

    if(Arvore->valor == valor)
        return Arvore;

    if(valor > Arvore->valor)
        if(Arvore->No_Dir == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Dir, valor);
    else
        if(Arvore->No_Esq == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Esq, valor);
}


void Incluir(Raiz *Arvore,int valor){
    Raiz * Novo_No;

    Novo_No =  (Raiz*) malloc(sizeof(Raiz));
    Novo_No->No_Dir = NULL;
    Novo_No->No_Esq = NULL;
    Novo_No->valor = valor;
    printf("Endereco arvore incluir %d\n", Arvore);
    Arvore = Novo_No;
    printf("Endereco arvore incluir2 %d\n", Arvore);
}



void Adiciona(Raiz *Arvore, int valor){
    Raiz * Arvore2;
    printf("Endereco arvore %d\n", Arvore);
    if(Arvore == NULL){
        Incluir(Arvore, valor);
        return 0;
    }else
    if(valor >= Arvore->valor){
        printf("recursivo\n");
        printf("Endereco arvore saida %d\n", Arvore->No_Dir);
        Adiciona(Arvore->No_Dir, valor);
    }
    else
        Adiciona(Arvore->No_Esq, valor);

}
void Imprime(Raiz* Arvore){
    if(!Arvore){
        printf("Saiu aqui\n");
        return 0;
    }
    printf("%d", Arvore->valor);
    printf("%d", Arvore->No_Dir);
    Imprime(Arvore->No_Dir);
    Imprime(Arvore->No_Esq);
}

int main(){
    Raiz *Arvore, *Arvore2, nova_arvore, *Mem;

    int valor, teste;


    Arvore = (Raiz*) malloc(sizeof(Arvore));
    Arvore->No_Dir = NULL;
    Arvore->No_Esq = NULL;

    if(Arvore == NULL)
        printf("ERRO!");

    Arvore->valor = 0;
    while( valor != 0 ){
            scanf("%d", &valor);
            Adiciona(Arvore, valor);
            printf("No dir: %d\n", Arvore->No_Dir);
    }



    Arvore2 = Arvore->No_Dir;
    printf("Valor :%d Valor2: %d\n", Arvore, Arvore2);

    Imprime(Arvore);

}

Cara to precisando mesmo da ajuda pra resolver isso então quem poder me dar uma luz desde já agradesço.

Link para o comentário
Compartilhar em outros sites

8 respostass a esta questão

Posts Recomendados

  • 0
PauloJr

PauloJr

Postado
  • Autor
Postado

A arvore tem que ser escrita em C, para não usar os recursos de C++.

PEriWinkle eu poderia usar da forma que você escreveu se eu definisse a função como sendo do tipo Raiz*. Então não podizer que ela

if(Raiz->valor < valor){
   Raiz->No_Dir = adiciona(Raiz->No_Dir,valor);
}
Já que é do tipo void, estudei um pouco mais e entendi que errei ao entender os argumentos como 
Adiciona(Raiz *Arvore, int valor){
teria que ser 
Adiciona(Raiz **Arvore, int valor){

Link para o comentário
Compartilhar em outros sites
  • 0
slinkkkk

slinkkkk

Postado
Postado (editado)

Aew brother dei uma mexida no teu codigo .. e fiz isso aki .. ve se te da uma ajuda

Claro que eu não fiz uma arvore funcional pois faltaria um algoritimo para re-organizar a arvore para ela ficar sempre balanceada.

Mas usei o q tu fez.

#include <stdio.h>

#include <stdlib.h>

#include <Windows.h>

typedef struct Raiz{

struct Raiz *No_Dir;

struct Raiz *No_Esq;

int valor;

}Raiz;

Raiz * Busca(Raiz *Arvore,int valor){

if(Arvore == NULL)

return Arvore;

if(Arvore->valor == valor)

return Arvore;

if(valor > Arvore->valor)

if(Arvore->No_Dir == NULL)

return Arvore;

else

Busca(Arvore->No_Dir, valor);

else

if(Arvore->No_Esq == NULL)

return Arvore;

else

Busca(Arvore->No_Esq, valor);

}

void Imprime(Raiz* Arvore){

if(Arvore == NULL){

printf("Saiu aqui\n");

}

else

{

printf("%d", Arvore->valor);

Imprime(Arvore->No_Dir);

Imprime(Arvore->No_Esq);

}

}

void Adiciona(Raiz *no,int valor)

{

if(no->valor == NULL)

no->valor = valor;

else

if(valor > no->valor)

{

if(no->No_Dir == NULL)

{

no->No_Dir = (Raiz*) malloc(sizeof(Raiz));

no->No_Dir->No_Dir = NULL;

no->No_Dir->No_Esq = NULL;

no->No_Dir->valor = NULL;

Adiciona(no->No_Dir,valor);

}

else

{

Adiciona(no->No_Dir,valor);

}

}

else

if(valor < no->valor)

{

if(no->No_Esq == NULL)

{

no->No_Esq = (Raiz*) malloc(sizeof(Raiz));

no->No_Esq->No_Dir = NULL;

no->No_Esq->No_Esq = NULL;

no->No_Esq->valor = NULL;

Adiciona(no->No_Esq,valor);

}

else

{

Adiciona(no->No_Esq,valor);

}

}

}

int main(){

Raiz *Arvore;

int valor = 20, teste;

Arvore = (Raiz*) malloc(sizeof(Raiz));

Arvore->No_Dir = NULL;

Arvore->No_Esq = NULL;

Arvore->valor = NULL;

if(Arvore == NULL)

printf("ERRO!");

while( true ){

scanf("%d", &valor);

if(valor == 0)

break;

Adiciona(Arvore, valor);

}

Imprime(Arvore);

system("PAUSE");

}

Editado por slinkkkk
Link para o comentário
Compartilhar em outros sites
  • 0
PauloJr

PauloJr

Postado
  • Autor
Postado

Cara muito obrigado pela sua resposta mais ainda vou dar uma tentada no ponteiro de ponteiro, para ver se entendo melhor como funciona.

Porém

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

typedef struct _raiz {
    int valor;
    struct _raiz *No_Dir;
    struct _raiz *No_Esq;
} Raiz;


Raiz *Busca(Raiz *Arvore,int valor){
    if(Arvore == NULL)
        return Arvore;

    if(Arvore->valor == valor)
        return Arvore;

    if(valor > Arvore->valor)
        if(Arvore->No_Dir == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Dir, valor);
    else
        if(Arvore->No_Esq == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Esq, valor);
}

void Imprime(Raiz* Arvore){
    if(!Arvore){
        printf("Saiu aqui\n");
        return 0;
    }
    printf("%d", Arvore->valor);
    printf("%d", Arvore->No_Dir);
    Imprime(Arvore->No_Dir);
    Imprime(Arvore->No_Esq);
}

void Incluir(Raiz **Arvore,int valor){
    Raiz * Novo_No;
    Novo_No =  (Raiz*) malloc(sizeof(Raiz));
    Novo_No->No_Dir = NULL;
    Novo_No->No_Esq = NULL;
    Novo_No->valor = valor;
    printf("Endereco arvore incluir %d\n", Arvore);
    (*Arvore) = Novo_No;
    printf("Endereco arvore incluir2 %d\n", Arvore);
}



void Adiciona(Raiz **Arvore, int valor){
    printf("Endereco arvore %d\n", Arvore);
    if(Arvore == NULL){
        Incluir(&Arvore, valor);
        return 0;
    }else
    if(valor >= (*Arvore)->valor){
        printf("recursivo\n");
        printf("Endereco arvore saida %d\n", (*Arvore)->No_Dir);
        Adiciona((*Arvore)->No_Dir, valor);
    }
    else
        Adiciona((*Arvore)->No_Esq, valor);

}

void troca(Raiz **Arvore, int valor){
    Raiz * Nova_raiz;
    Nova_raiz = (Raiz*) malloc(sizeof(Raiz*));
    printf("Endereco antes troca:%d\n", Arvore);
    (*Arvore) = Nova_raiz;
    (*Arvore)->valor = valor;
    printf("Endereco depois troca:%d\n", Arvore);
}
int main(){
    Raiz *Arvore, *Arvore2, nova_arvore, *Mem;

    int valor, teste;


    Arvore = (Raiz*) malloc(sizeof(Arvore));
    Arvore->No_Dir = NULL;
    Arvore->No_Esq = NULL;

    if(Arvore == NULL)
        printf("ERRO!");

    Arvore->valor = 0;
    while( valor != 0 ){
            scanf("%d", &valor);
            Adiciona(&Arvore, valor);
            printf("No dir: %d\n", Arvore->No_Dir);
    }




    Imprime(Arvore);
    printf("\nValor :%d Valor2: %d\n", Arvore, Arvore2);

    scanf("%d", &valor);

    printf("antes troca %d  endereco %d\n", Arvore->valor, Arvore);
    troca(&Arvore, valor);
    printf("depois troca %d endereco %d\n", (*Arvore).valor, Arvore);


}
Me gera os seguintes erros: 
G:\Algoritmo\Arvore.c||In function 'Imprime':|
G:\Algoritmo\Arvore.c|33|warning: 'return' with a value, in function returning void|
G:\Algoritmo\Arvore.c||In function 'Adiciona':|
G:\Algoritmo\Arvore.c|57|warning: passing argument 1 of 'Incluir' from incompatible pointer type|
G:\Algoritmo\Arvore.c|41|note: expected 'struct Raiz **' but argument is of type 'struct Raiz ***'|
G:\Algoritmo\Arvore.c|58|warning: 'return' with a value, in function returning void|
G:\Algoritmo\Arvore.c|63|warning: passing argument 1 of 'Adiciona' from incompatible pointer type|
G:\Algoritmo\Arvore.c|54|note: expected 'struct Raiz **' but argument is of type 'struct _raiz *'|
G:\Algoritmo\Arvore.c|66|warning: passing argument 1 of 'Adiciona' from incompatible pointer type|
G:\Algoritmo\Arvore.c|54|note: expected 'struct Raiz **' but argument is of type 'struct _raiz *'|
||=== Build finished: 3 errors, 5 warnings ===|

Gostaria de saber se alguém me explica o erro da linha 41.

Link para o comentário
Compartilhar em outros sites
  • 0
PauloJr

PauloJr

Postado
  • Autor
Postado

Depois de muito tentar e ler um pouco conseguir resolver o problema, fica solução caso alguém tenha o mesmo problema que eu.

Eu não testei a busca, e é somente um Arvore binária.

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

typedef struct _raiz {
    int valor;
    struct _raiz *No_Dir;
    struct _raiz *No_Esq;
} Raiz;


Raiz *Busca(Raiz *Arvore,int valor){
    if(Arvore == NULL)
        return Arvore;

    if(Arvore->valor == valor)
        return Arvore;

    if(valor > Arvore->valor)
        if(Arvore->No_Dir == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Dir, valor);
    else
        if(Arvore->No_Esq == NULL)
            return Arvore;
        else
            Busca(Arvore->No_Esq, valor);
}

void Imprime(Raiz* Arvore){
    if(!Arvore)
        return 0;
    printf("%d\n", Arvore->valor);
    Imprime(Arvore->No_Dir);
    Imprime(Arvore->No_Esq);
}

void Incluir(Raiz ** Arvore, int valor){
    Raiz * Novo_No;

    Novo_No = (Raiz*) malloc(sizeof(Raiz));
    Novo_No->No_Dir = NULL;
    Novo_No->No_Esq = NULL;
    Novo_No->valor  = valor;

    (*Arvore) = Novo_No;
};

void Adiciona(Raiz ** Arvore, int valor){
    Raiz * No_Aux;
    if(!(*Arvore)){
        Incluir(&(*Arvore), valor);
        return 0;
    }
    if(valor >= (*Arvore)->valor){
        Adiciona(&(*Arvore)->No_Dir, valor);
    }
    else
        Adiciona(&(*Arvore)->No_Esq, valor);


};

int main(){
    Raiz *Arvore, *Arvore2, nova_arvore, *Mem;

    int valor, teste;


    Arvore = (Raiz*) malloc(sizeof(Arvore));
    Arvore->No_Dir = NULL;
    Arvore->No_Esq = NULL;

    if(Arvore == NULL)
        printf("ERRO!");

    Arvore->valor = 0;
    while( valor != 0 ){
            scanf("%d", &valor);
            Adiciona(&Arvore, valor);
    }

    Imprime(Arvore);


}

Link para o comentário
Compartilhar em outros sites

Participe da discussão

Você pode postar agora e se registrar depois. Se você já tem uma conta, acesse agora para postar com sua conta.

Visitante
Responder esta pergunta...

×   Você colou conteúdo com formatação.   Remover formatação

  Apenas 75 emoticons são permitidos.

×   Seu link foi incorporado automaticamente.   Exibir como um link em vez disso

×   Seu conteúdo anterior foi restaurado.   Limpar Editor

×   Você não pode colar imagens diretamente. Carregar ou inserir imagens do URL.

×
 Share
Ir para lista de Perguntas


  • Estatísticas dos Fóruns

    • Tópicos
      152,2k
    • Posts
      652k
×
×
  • Criar Novo...