A maior rede de estudos do Brasil

Implementação do método Em Linha(Arvore Binária)

private void PreencheVectorEmLinha(Nodo<TKey,TValue> raiz,

ParChaveValor<TKey,TValue>[] vector)


4 resposta(s) - Contém resposta de Especialista

User badge image

RD Resoluções Verified user icon

Há mais de um mês

Para a resolução da questão foram utilizados conhecimentos em C++ e algoritmos.


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <iomanip>

using namespace std;

struct noh

{

int info;

struct noh*esq;

struct noh*dir;

};

typedef struct noh arvore;

arvore* arv_criavazia(void)

{

return NULL;

}

arvore* arv_cria(char c, arvore*sae, arvore*sad)

{

arvore*p = (arvore*)malloc(sizeof(arvore)); //cria o nó

if(p == NULL)exit(1);

p->info;

p->esq = sae;

p->dir = sad;

return p;

}

int arv_vazia(arvore*a)

{

return NULL;

}

arvore *arv_libera(arvore*a)

{

if(!arv_vazia(a))

{

arv_libera(a->esq);

arv_libera(a->dir);

free(a);

}

return NULL;

}

int arv_criavazia(arvore*a)

{

return a == NULL;

}

int arv_pertence(arvore*a, char c)

{

if(arv_vazia(a))

{

return 0;

}

else

{

return a->info == c || arv_pertence(a->esq, c) || arv_pertence(a->dir, c);

}

}

void arv_imprimeo(arvore*a)

{

if(!arv_vazia(a))

{

arv_imprimeo(a->esq);

printf("%c", a->info);

arv_imprimeo(a->dir);

}

}

arvore*abb_insere(arvore *a, int v)

{

if(a == NULL)

{

a = (arvore*)malloc(sizeof(arvore));

a->info = v;

a->esq = a->dir = NULL;

}

else if(v < a->info)

a->esq = abb_insere(a->esq, v);

else

{

a->dir = abb_insere(a->dir, v);

}

return a;

}

arvore*abb_retira(arvore*r, int v)

{

if (r == NULL)

{

return NULL;

}

else if(r->info > v)

{

r->esq = abb_retira(r->esq, v);

}

else if(r->info < v)

{

r->dir = abb_retira(r->dir, v);

}

else

{

if(r->esq = NULL && r->dir == NULL)

{

free(r);

r = NULL;

}

else if(r->esq == NULL)

{

arvore*t = r;

r = r->dir;

free(t);

}

else if(r->dir == NULL)

{

arvore*t = r;

r = r->esq;

free(t);

}

else

{

arvore*f = r->esq;

while(f->dir != NULL)

{

f = f->dir;

}

r->info = f->info;

f->info = v;

r->esq = abb_retira(r->esq, v);

}

}

return r;

}

int main()

{

arvore*a1 = arv_cria('4', arv_criavazia(), arv_criavazia());

arvore*a2 = arv_cria('9', a1, arv_criavazia());

arvore*a3 = arv_cria('5', arv_criavazia(), a2);

arvore*a4 = arv_cria('5', arv_criavazia(), arv_criavazia());

arvore*a5 = arv_cria('11', arv_criavazia(), arv_criavazia());

arvore*a6 = arv_cria('6', a4, a5);

arvore*a7 = arv_cria('2', arv_criavazia(), arv_criavazia());

arvore*a8 = arv_cria('7', a7, a6);

arvore*a = arv_cria('2', a8, a3);

int n;

int info;

printf(" ____ ____ ____ ____ ____ ____ \n");

printf(" ||* |||M |||E |||N |||U |||* ||\n");

printf(" ||__|||__|||__|||__|||__|||__||\n");

printf(" |/__\\|/__\\|/__\\|/__\\|/__\\|/__\\|\n\n");

printf("1 - Imprimir em ordem\n");

printf("2 - Inserir elementos\n");

printf("3 - Excluir elementos\n");

printf("4 - Sair\n");

printf("Opcao: \n");

while(1)

{

scanf("%d", &n);

if(n == 4)break;

switch(n)

{

case 1:

arv_imprimeo(a);

break;

case 2:

abb_insere(a);

break;

case 3:

abb_retira(a);

break;

}

}

}

Para a resolução da questão foram utilizados conhecimentos em C++ e algoritmos.


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <iomanip>

using namespace std;

struct noh

{

int info;

struct noh*esq;

struct noh*dir;

};

typedef struct noh arvore;

arvore* arv_criavazia(void)

{

return NULL;

}

arvore* arv_cria(char c, arvore*sae, arvore*sad)

{

arvore*p = (arvore*)malloc(sizeof(arvore)); //cria o nó

if(p == NULL)exit(1);

p->info;

p->esq = sae;

p->dir = sad;

return p;

}

int arv_vazia(arvore*a)

{

return NULL;

}

arvore *arv_libera(arvore*a)

{

if(!arv_vazia(a))

{

arv_libera(a->esq);

arv_libera(a->dir);

free(a);

}

return NULL;

}

int arv_criavazia(arvore*a)

{

return a == NULL;

}

int arv_pertence(arvore*a, char c)

{

if(arv_vazia(a))

{

return 0;

}

else

{

return a->info == c || arv_pertence(a->esq, c) || arv_pertence(a->dir, c);

}

}

void arv_imprimeo(arvore*a)

{

if(!arv_vazia(a))

{

arv_imprimeo(a->esq);

printf("%c", a->info);

arv_imprimeo(a->dir);

}

}

arvore*abb_insere(arvore *a, int v)

{

if(a == NULL)

{

a = (arvore*)malloc(sizeof(arvore));

a->info = v;

a->esq = a->dir = NULL;

}

else if(v < a->info)

a->esq = abb_insere(a->esq, v);

else

{

a->dir = abb_insere(a->dir, v);

}

return a;

}

arvore*abb_retira(arvore*r, int v)

{

if (r == NULL)

{

return NULL;

}

else if(r->info > v)

{

r->esq = abb_retira(r->esq, v);

}

else if(r->info < v)

{

r->dir = abb_retira(r->dir, v);

}

else

{

if(r->esq = NULL && r->dir == NULL)

{

free(r);

r = NULL;

}

else if(r->esq == NULL)

{

arvore*t = r;

r = r->dir;

free(t);

}

else if(r->dir == NULL)

{

arvore*t = r;

r = r->esq;

free(t);

}

else

{

arvore*f = r->esq;

while(f->dir != NULL)

{

f = f->dir;

}

r->info = f->info;

f->info = v;

r->esq = abb_retira(r->esq, v);

}

}

return r;

}

int main()

{

arvore*a1 = arv_cria('4', arv_criavazia(), arv_criavazia());

arvore*a2 = arv_cria('9', a1, arv_criavazia());

arvore*a3 = arv_cria('5', arv_criavazia(), a2);

arvore*a4 = arv_cria('5', arv_criavazia(), arv_criavazia());

arvore*a5 = arv_cria('11', arv_criavazia(), arv_criavazia());

arvore*a6 = arv_cria('6', a4, a5);

arvore*a7 = arv_cria('2', arv_criavazia(), arv_criavazia());

arvore*a8 = arv_cria('7', a7, a6);

arvore*a = arv_cria('2', a8, a3);

int n;

int info;

printf(" ____ ____ ____ ____ ____ ____ \n");

printf(" ||* |||M |||E |||N |||U |||* ||\n");

printf(" ||__|||__|||__|||__|||__|||__||\n");

printf(" |/__\\|/__\\|/__\\|/__\\|/__\\|/__\\|\n\n");

printf("1 - Imprimir em ordem\n");

printf("2 - Inserir elementos\n");

printf("3 - Excluir elementos\n");

printf("4 - Sair\n");

printf("Opcao: \n");

while(1)

{

scanf("%d", &n);

if(n == 4)break;

switch(n)

{

case 1:

arv_imprimeo(a);

break;

case 2:

abb_insere(a);

break;

case 3:

abb_retira(a);

break;

}

}

}

User badge image

Andre

Há mais de um mês

Para a resolução da questão foram utilizados conhecimentos em C++ e algoritmos.


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <iomanip>

using namespace std;

struct noh

{

int info;

struct noh*esq;

struct noh*dir;

};

typedef struct noh arvore;

arvore* arv_criavazia(void)

{

return NULL;

}

arvore* arv_cria(char c, arvore*sae, arvore*sad)

{

arvore*p = (arvore*)malloc(sizeof(arvore)); //cria o nó

if(p == NULL)exit(1);

p->info;

p->esq = sae;

p->dir = sad;

return p;

}

int arv_vazia(arvore*a)

{

return NULL;

}

arvore *arv_libera(arvore*a)

{

if(!arv_vazia(a))

{

arv_libera(a->esq);

arv_libera(a->dir);

free(a);

}

return NULL;

}

int arv_criavazia(arvore*a)

{

return a == NULL;

}

int arv_pertence(arvore*a, char c)

{

if(arv_vazia(a))

{

return 0;

}

else

{

return a->info == c || arv_pertence(a->esq, c) || arv_pertence(a->dir, c);

}

}

void arv_imprimeo(arvore*a)

{

if(!arv_vazia(a))

{

arv_imprimeo(a->esq);

printf("%c", a->info);

arv_imprimeo(a->dir);

}

}

arvore*abb_insere(arvore *a, int v)

{

if(a == NULL)

{

a = (arvore*)malloc(sizeof(arvore));

a->info = v;

a->esq = a->dir = NULL;

}

else if(v < a->info)

a->esq = abb_insere(a->esq, v);

else

{

a->dir = abb_insere(a->dir, v);

}

return a;

}

arvore*abb_retira(arvore*r, int v)

{

if (r == NULL)

{

return NULL;

}

else if(r->info > v)

{

r->esq = abb_retira(r->esq, v);

}

else if(r->info < v)

{

r->dir = abb_retira(r->dir, v);

}

else

{

if(r->esq = NULL && r->dir == NULL)

{

free(r);

r = NULL;

}

else if(r->esq == NULL)

{

arvore*t = r;

r = r->dir;

free(t);

}

else if(r->dir == NULL)

{

arvore*t = r;

r = r->esq;

free(t);

}

else

{

arvore*f = r->esq;

while(f->dir != NULL)

{

f = f->dir;

}

r->info = f->info;

f->info = v;

r->esq = abb_retira(r->esq, v);

}

}

return r;

}

int main()

{

arvore*a1 = arv_cria('4', arv_criavazia(), arv_criavazia());

arvore*a2 = arv_cria('9', a1, arv_criavazia());

arvore*a3 = arv_cria('5', arv_criavazia(), a2);

arvore*a4 = arv_cria('5', arv_criavazia(), arv_criavazia());

arvore*a5 = arv_cria('11', arv_criavazia(), arv_criavazia());

arvore*a6 = arv_cria('6', a4, a5);

arvore*a7 = arv_cria('2', arv_criavazia(), arv_criavazia());

arvore*a8 = arv_cria('7', a7, a6);

arvore*a = arv_cria('2', a8, a3);

int n;

int info;

printf(" ____ ____ ____ ____ ____ ____ \n");

printf(" ||* |||M |||E |||N |||U |||* ||\n");

printf(" ||__|||__|||__|||__|||__|||__||\n");

printf(" |/__\\|/__\\|/__\\|/__\\|/__\\|/__\\|\n\n");

printf("1 - Imprimir em ordem\n");

printf("2 - Inserir elementos\n");

printf("3 - Excluir elementos\n");

printf("4 - Sair\n");

printf("Opcao: \n");

while(1)

{

scanf("%d", &n);

if(n == 4)break;

switch(n)

{

case 1:

arv_imprimeo(a);

break;

case 2:

abb_insere(a);

break;

case 3:

abb_retira(a);

break;

}

}

}

User badge image

Vitor

Há mais de um mês

Legal, muito interessntes

User badge image

Andre

Há mais de um mês

Para a resolução da questão foram utilizados conhecimentos em C++ e algoritmos.


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <iomanip>

using namespace std;

struct noh

{

int info;

struct noh*esq;

struct noh*dir;

};

typedef struct noh arvore;

arvore* arv_criavazia(void)

{

return NULL;

}

arvore* arv_cria(char c, arvore*sae, arvore*sad)

{

arvore*p = (arvore*)malloc(sizeof(arvore)); //cria o nó

if(p == NULL)exit(1);

p->info;

p->esq = sae;

p->dir = sad;

return p;

}

int arv_vazia(arvore*a)

{

return NULL;

}

arvore *arv_libera(arvore*a)

{

if(!arv_vazia(a))

{

arv_libera(a->esq);

arv_libera(a->dir);

free(a);

}

return NULL;

}

int arv_criavazia(arvore*a)

{

return a == NULL;

}

int arv_pertence(arvore*a, char c)

{

if(arv_vazia(a))

{

return 0;

}

else

{

return a->info == c || arv_pertence(a->esq, c) || arv_pertence(a->dir, c);

}

}

void arv_imprimeo(arvore*a)

{

if(!arv_vazia(a))

{

arv_imprimeo(a->esq);

printf("%c", a->info);

arv_imprimeo(a->dir);

}

}

arvore*abb_insere(arvore *a, int v)

{

if(a == NULL)

{

a = (arvore*)malloc(sizeof(arvore));

a->info = v;

a->esq = a->dir = NULL;

}

else if(v < a->info)

a->esq = abb_insere(a->esq, v);

else

{

a->dir = abb_insere(a->dir, v);

}

return a;

}

arvore*abb_retira(arvore*r, int v)

{

if (r == NULL)

{

return NULL;

}

else if(r->info > v)

{

r->esq = abb_retira(r->esq, v);

}

else if(r->info < v)

{

r->dir = abb_retira(r->dir, v);

}

else

{

if(r->esq = NULL && r->dir == NULL)

{

free(r);

r = NULL;

}

else if(r->esq == NULL)

{

arvore*t = r;

r = r->dir;

free(t);

}

else if(r->dir == NULL)

{

arvore*t = r;

r = r->esq;

free(t);

}

else

{

arvore*f = r->esq;

while(f->dir != NULL)

{

f = f->dir;

}

r->info = f->info;

f->info = v;

r->esq = abb_retira(r->esq, v);

}

}

return r;

}

int main()

{

arvore*a1 = arv_cria('4', arv_criavazia(), arv_criavazia());

arvore*a2 = arv_cria('9', a1, arv_criavazia());

arvore*a3 = arv_cria('5', arv_criavazia(), a2);

arvore*a4 = arv_cria('5', arv_criavazia(), arv_criavazia());

arvore*a5 = arv_cria('11', arv_criavazia(), arv_criavazia());

arvore*a6 = arv_cria('6', a4, a5);

arvore*a7 = arv_cria('2', arv_criavazia(), arv_criavazia());

arvore*a8 = arv_cria('7', a7, a6);

arvore*a = arv_cria('2', a8, a3);

int n;

int info;

printf(" ____ ____ ____ ____ ____ ____ \n");

printf(" ||* |||M |||E |||N |||U |||* ||\n");

printf(" ||__|||__|||__|||__|||__|||__||\n");

printf(" |/__\\|/__\\|/__\\|/__\\|/__\\|/__\\|\n\n");

printf("1 - Imprimir em ordem\n");

printf("2 - Inserir elementos\n");

printf("3 - Excluir elementos\n");

printf("4 - Sair\n");

printf("Opcao: \n");

while(1)

{

scanf("%d", &n);

if(n == 4)break;

switch(n)

{

case 1:

arv_imprimeo(a);

break;

case 2:

abb_insere(a);

break;

case 3:

abb_retira(a);

break;

}

}

}

Essa pergunta já foi respondida por um dos nossos especialistas