search

giiff / livro_algoritmos_e_estruturas_de_dados

Livro Algoritmos e Estruturas de Dados para Tecnólogos
Creative Commons Attribution Share Alike 4.0 International
13 stars 0 forks source link

Implementar um método que informe a altura da árvore binária #16

Closed waldeyr closed 4 years ago

4ven commented 4 years ago 
// Samuel Sergio Garcia Espinosa

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

typedef struct No{
  int dado;
  struct No* direita;
  struct No* esquerda;
} No;

int altura = 0;

No* criarArvore(){
  return NULL;
}

int NoVazia(No* raiz){
  // 1 se a arvore for vazia
  // 0 caso contrario 
  return raiz == NULL;
}

void exibirNo(No* raiz){
  if(!NoVazia(raiz)){ //No nao vazio
    printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
    exibirNo(raiz->esquerda);//esquerda (subNo)
    exibirNo(raiz->direita); //direita (subNo)
  }
}

void inserirDado(No** raiz, int dado){
    if(*raiz == NULL){
      *raiz = (No*)malloc(sizeof(No));
      (*raiz)->esquerda = NULL; 
      (*raiz)->direita = NULL; 
      (*raiz)->dado = dado; 
    } else {
        if(dado < (*raiz)->dado){ //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if(dado > (*raiz)->dado){ //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

void buscarDado(No** raiz, int dado)
{
    if(*raiz == NULL)
        printf("O dado não existe \n");
    else
    {
        if(dado == (*raiz)->dado)
            printf("O dado existe \n");
        else if(dado < (*raiz)->dado)
            buscarDado(&(*raiz)->esquerda, dado);
        else if(dado > (*raiz)->dado)
            buscarDado(&(*raiz)->direita, dado);
    }
}

void alturaArvore(No** raiz)
{
    if(*raiz != NULL)
    {
        altura++;

        if( &(*raiz)->esquerda->dado != NULL && &(*raiz)->direita->dado != NULL ) 
        {
            altura--;
            alturaArvore(&(*raiz)->esquerda);
            alturaArvore(&(*raiz)->direita);
        }
        else if( &(*raiz)->esquerda->dado != NULL && &(*raiz)->direita->dado == NULL )
            alturaArvore(&(*raiz)->esquerda);
        else if( &(*raiz)->esquerda->dado == NULL && &(*raiz)->direita->dado != NULL )
            alturaArvore(&(*raiz)->direita);
    }
}

void main(){
  No* raiz = criarArvore();
  inserirDado(&raiz, 50); 
  inserirDado(&raiz, 25); 
  inserirDado(&raiz, 75); 
  inserirDado(&raiz, 5); 
  //exibirNo(raiz);
  //printf("Procurando o dado... \n");
  //buscarDado(&raiz, 74);
  alturaArvore(&raiz);
  printf("A altura da arvore é: %d \n", altura);

  free(raiz);
  system("echo 'digraph G {a->b; a->c;b->d;}' | dot -Tpng >teste.png");

}
MatheusMagga commented 4 years ago 
//Matheus de Almeida Magalhães
#include <stdio.h>
#include <stdlib.h>

typedef struct No
{
    int dado;
    struct No *direita;
    struct No *esquerda;
} No;

No *criarArvore()
{
    return NULL;
}

int NoVazia(No *raiz)
{
    // 1 se a arvore for vazia
    // 0 caso contrario
    return raiz == NULL;
}

void exibirNo(No *raiz)
{
    if (!NoVazia(raiz))
    { //No nao vazio
        printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
        exibirNo(raiz->esquerda); //esquerda (subNo)
        exibirNo(raiz->direita);  //direita (subNo)
    }
}

void inserirDado(No **raiz, int dado)
{
    if (*raiz == NULL)
    {
        *raiz = (No *)malloc(sizeof(No));
        (*raiz)->esquerda = NULL;
        (*raiz)->direita = NULL;
        (*raiz)->dado = dado;
    }
    else
    {
        if (dado < (*raiz)->dado)
        { //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if (dado > (*raiz)->dado)
        { //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

void buscarDado(No *r, int dado)
{
    if (r == NULL || r->dado == dado)
    {
        printf("Dado %d encontrado\n", r->dado);
    }
    if (r->dado > dado)
    {
        buscarDado(r->esquerda, dado);
    }
    else
    {
        buscarDado(r->direita, dado);
    }
}

int altura = 0;

void altArvore(No *raiz)
{
    if (raiz != NULL)
    {
        altura++;

        if (raiz->esquerda->dado != NULL && raiz->direita->dado != NULL)
        {
            altura--;
            altArvore(raiz->esquerda);
            altArvore(raiz->direita);
        }
        else if (raiz->esquerda->dado != NULL && raiz->direita->dado == NULL)
            altArvore(raiz->esquerda);
        else if (raiz->esquerda->dado == NULL && raiz->direita->dado != NULL)
            altArvore(raiz->direita);
    }
}

void main()
{
    No *raiz = criarArvore();
    inserirDado(&raiz, 50);
    inserirDado(&raiz, 25);
    inserirDado(&raiz, 75);
    inserirDado(&raiz, 5);
    exibirNo(raiz);
    buscarDado(raiz, 25);
    altArvore(raiz);
    printf("Altura é: %d", altura);
    free(raiz);
ghost commented 4 years ago

Guilherme Henrique Lopes de Almeida Saraiva

#include <stdio.h>
#include <stdlib.h>
//Struct tree
typedef struct Node{
  int item;
  struct Node *lefth;
  struct Node *right;
} Node;
//Functions prototypes
void Create( Node**, int );
void Read( Node* );
void Search(Node**, int );
int Measure(Node* );
int More(int , int );
//General functions

//Functions of binary tree
//Creating
void Create( Node **root, int data ){
    if( *root == NULL ){
      *root = (Node*) malloc( sizeof(Node) );
      (*root)->lefth = NULL; 
      (*root)->right = NULL; 
      (*root)->item = data; 
    } else {
        if(data < (*root)->item){
            Create( &(*root)->lefth, data );
        }
        if(data > (*root)->item){
            Create( &(*root)->right, data );
        }
    }
}
//Reading
void Read(Node* root){
  if(root != NULL){
    printf("%p<-%d(%p)->%p\n\n", root->lefth, root->item, root, root->right);
    Read(root->lefth);
    Read(root->right); 
  }
}
//Searching
void Search(Node** root, int data){
    if(*root == NULL)
        puts("Data not found!");
    else
    {
        if(data == (*root)->item)
            printf("Data found:");
            //printf("%p<-%d(%p)->%p\n\n", root->lefth, root->item, root, root->right);
        else if(data < (*root)->item)
            Search(&(*root)->lefth, data);
        else if(data > (*root)->item)
            Search(&(*root)->right, data);
    }
}
//Measuring
int More(int x, int y){
    if (x > y)
        return x;
    else
        return y;
}
int Measure(Node *root){
   if((root == NULL) || (root->lefth == NULL && root->right == NULL))
       return 0;
   else
       return 1 + More(Measure(root->lefth), Measure(root->right));
}
//End functions
//Main
int main(void){
    Node *root = NULL;
    for (int i = 0; i < 5; i++)
        Create(&root, rand() %100);
    Read(root);
    printf("The lenght tree is: %i", Measure(root));
    free(root);
    return 0;
}
1234567890asdf commented 4 years ago

`//Cristiano Gomes Machado

include

include

typedef struct No{ int dado; struct No direita; struct No esquerda; } No;

No* criarArvore(){ return NULL; }

int NoVazia(No* raiz){ // 1 se a arvore for vazia // 0 caso contrario return raiz == NULL; }

void exibirArvore(No* raiz){ if(!NoVazia(raiz)){ //No nao vazio printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); exibirNo(raiz->esquerda); exibirNo(raiz->direita); } } void inserirDado(No* raiz, int dado){ if(raiz == NULL){ raiz = (No)malloc(sizeof(No)); (raiz)->esquerda = NULL; (raiz)->direita = NULL; (raiz)->dado = dado; } else { if(dado < (raiz)->dado){ //Se o dado é menor que a raiz vai para esquerda //percorrer subNo da esquerda inserirDado(&(raiz)->esquerda, dado); } if(dado > (raiz)->dado){ //Se o dado é maior que a raiz vai para a direita //percorrer subNo da direita inserirDado(&(*raiz)->direita, dado); } } }

void buscarDado (No* raiz, int dado) { if(raiz == NULL){ printf("dado nao existente\n"); } else{ if(dado == (raiz)->dado) printf("O dado existe \n"); else if(dado < (raiz)->dado) buscarDado(&(raiz)->esquerda, dado); else if(dado > (raiz)->dado) buscarDado(&(*raiz)->direita, dado); } }

void altura(No* raiz){ if(raiz != NULL){ altura++;

    if( &(*raiz)->esquerda->dado != NULL && &(*raiz)->direita->dado != NULL ) {
        altura--;
        altura(&(*raiz)->esquerda);
        altura(&(*raiz)->direita);
    }
    else if( &(*raiz)->esquerda->dado != NULL && &(*raiz)->direita->dado == NULL )
        altura(&(*raiz)->esquerda);
    else if( &(*raiz)->esquerda->dado == NULL && &(*raiz)->direita->dado != NULL )
        altura(&(*raiz)->direita);
}

}

void main(){ No* raiz = criarArvore(); inserirDado(&raiz, 50); inserirDado(&raiz, 25); inserirDado(&raiz, 75); inserirDado(&raiz, 5); //exibirArvore(raiz); altura(&raiz); printf("A altura da arvore é: %d \n", altura);

free(raiz); // system("echo 'digraph G {a->b; a->c;b->d;}' | dot -Tpng >teste.png"); //buscar(&raiz, 5); }

`

arthurjf commented 4 years ago

Aluno: Arthur José Fernandes

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

typedef struct No {
    int dado;
    struct No* direita;
    struct No* esquerda;
} No;

No* criarArvore() {
    return NULL;
}

int NoVazia(No* raiz) { // 1 se a arvore vazia, 0 caso contrario 
    return raiz == NULL;
}

void mostrarArvore(No* raiz) {
    if (!NoVazia(raiz)) { //No nao vazio
        printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
        mostrarArvore(raiz->esquerda); //esquerda (subNo)
        mostrarArvore(raiz->direita); //direita (subNo)
    }
}

void buscarDado(No** raiz, int dado) {
    if (!NoVazia(*raiz)) { //No nao vazio
        if (dado == (*raiz)->dado) {
            printf("%d encontrado.\n", dado);
            return;
        } else {
            if (dado < (*raiz)->dado) { //dado menor? vai pra esquerda
                buscarDado(&(*raiz)->esquerda, dado);
            }
            if (dado > (*raiz)->dado) { //dado maior? vai pra direita
                buscarDado(&(*raiz)->direita, dado);
            }
        }
    }
}

void inserirDado(No** raiz, int dado) {
    if (*raiz == NULL) {
        *raiz = (No*) malloc(sizeof (No));
        (*raiz)->esquerda = NULL;
        (*raiz)->direita = NULL;
        (*raiz)->dado = dado;
    } else {
        if (dado < (*raiz)->dado) { //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if (dado > (*raiz)->dado) { //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

int alturaArvore(No* raiz) {
    if (raiz == NULL)
        return 0;
    else {
        int alturaEsquerda = alturaArvore(raiz->esquerda);
        int alturaDireita = alturaArvore(raiz->direita);
        if (alturaEsquerda < alturaDireita) {
            return alturaDireita + 1;
        } else {
            return alturaEsquerda + 1;
        }
    }
}

void pegarAlturaArvore(No* raiz) {
    printf("A árvore tem altura: %d\n\n", alturaArvore(raiz));
}

void main() {
    No* raiz = criarArvore();
    srand(time(NULL));
    for (int i = 0; i < 20; i++) {
        inserirDado(&raiz, rand() % 21);
    }
    mostrarArvore(raiz);
    buscarDado(&raiz, 7);
    pegarAlturaArvore(raiz);
    free(raiz);
    //system("echo 'digraph G {a->b; a->c;b->d;}' | dot -Tpng >teste.png");
}
Judy-Ellen commented 4 years ago

JUDY ELLEN VERA MARTINS

include

include

typedef struct No{ int dado; struct No direita; struct No esquerda; } No;

int alt = 0;

No* criarArvore(){ return NULL; }

int NoVazia(No* raiz){ return raiz == NULL; }

void exibirNo(No* raiz){ if(!NoVazia(raiz)){ printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); exibirNo(raiz->esquerda); exibirNo(raiz->direita); } }

void inserirDado(No* raiz, int dado){ if(raiz == NULL){ raiz = (No)malloc(sizeof(No)); (raiz)->esquerda = NULL; (raiz)->direita = NULL; (raiz)->dado = dado; } else { if(dado < (raiz)->dado){ //dado menor irá p esquerda inserirDado(&(raiz)->esquerda, dado); } if(dado > (raiz)->dado){ //dado maior irá p direita inserirDado(&(*raiz)->direita, dado); } } }

void buscarDado(No* raiz, int dado) { if(raiz == NULL) printf("O dado não existe \n"); else { if(dado == (raiz)->dado) printf("O dado existe \n"); else if(dado < (raiz)->dado) buscarDado(&(raiz)->esquerda, dado); else if(dado > (raiz)->dado) buscarDado(&(*raiz)->direita, dado); } }

void alturaArvore(No* raiz) { if(raiz != NULL) { alt++; if( &(raiz)->esquerda->dado != NULL && &(raiz)->direita->dado != NULL ) { alt--; alturaArvore(&(raiz)->esquerda); alturaArvore(&(raiz)->direita); } else if( &(raiz)->esquerda->dado != NULL && &(raiz)->direita->dado == NULL ) alturaArvore(&(raiz)->esquerda); else if( &(raiz)->esquerda->dado == NULL && &(raiz)->direita->dado != NULL ) alturaArvore(&(raiz)->direita); } }

void main(){ No* raiz = criarArvore(); inserirDado(&raiz, 75); inserirDado(&raiz, 80); inserirDado(&raiz, 24); inserirDado(&raiz, 10); alturaArvore(&raiz); printf("A altura da arvore é: %d \n", alt);

free(raiz); }

Samuel-Amaro commented 4 years ago 

//Aluno: Samuel Amaro
//IMPLEMENTA UM METODO QUE DESCUBRA A HALTURA DE UMA ARVORE

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

//variavel global static que conta hatura da arvore
static int halturaArvore = 0;

typedef struct No{
  int dado;
  struct No* direita;
  struct No* esquerda;
} No;

No* criarArvore(){
  return NULL;
}

int NoVazia(No* raiz){
  // 1 se a arvore for vazia
  // 0 caso contrario
  return raiz == NULL;
}

void exibirNo(No* raiz){
  if(!NoVazia(raiz)){ //No nao vazio
    printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
    exibirNo(raiz->esquerda);//esquerda (subNo)
    exibirNo(raiz->direita); //direita (subNo)
  }
}

void inserirDado(No** raiz, int dado){
    if(*raiz == NULL){
       *raiz = (No*)malloc(sizeof(No));
      (*raiz)->esquerda = NULL;
      (*raiz)->direita = NULL;
      (*raiz)->dado = dado;
    } else {
        if(dado < (*raiz)->dado){ //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if(dado > (*raiz)->dado){ //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

//implemeta uma função buscar dado na arvore
void buscarDado(No **raiz,int dado);
void buscarDado(No **raiz,int dado) {
 if(*raiz == NULL) {
    printf("Arvore Vazia!");
 }else {
      if(dado == (*raiz)->dado) {
        printf("Dado encontrado!\n");
        return;
      }

      if(dado < (*raiz)->dado) {
         //sempre vai atualizando e percorrendo um sub no da esquerda de um novo no que foi atualizado
         buscarDado(&(*raiz)->esquerda,dado);
      }
      if(dado > (*raiz)->dado) {
         //sempre vai atualizando e percorrendo um sub no da direita, para um novo no atualizado
         buscarDado(&(*raiz)->direita,dado);
      }
 }

}

static int halturaEsquerda = 0;
static int halturaDireita = 0;
int alturaArvore(No** raiz);
int alturaArvore(No** raiz) {
 if(*raiz == NULL) {
    return -1;
 }
 else {

      //se um no a esquerda e direita não e null, imcrementa
      if((*raiz)->esquerda != NULL && (*raiz)->direita != NULL) {
        halturaEsquerda = alturaArvore(&(*raiz)->esquerda);
        halturaDireita = alturaArvore(&(*raiz)->direita);
        halturaArvore += 1;
      }
      //se um no a esquerda e null e a direita não e, incrementa
      if((*raiz)->esquerda == NULL && (*raiz)->direita != NULL) {
         halturaDireita = alturaArvore(&(*raiz)->direita);
         halturaArvore += 1;
      }
      //se um no a direita e null e a esquerda não e, incrementa
      if((*raiz)->direita == NULL && (*raiz)->esquerda != NULL) {
         halturaEsquerda = alturaArvore(&(*raiz)->esquerda);
         halturaArvore += 1;
      }
      //aqui e para verificar em qual dos lados da raiz a altura e maior
      if(halturaEsquerda > halturaDireita) {
         return halturaEsquerda;
      }if(halturaDireita > halturaEsquerda){
          return halturaDireita;
      }

 }
}

void main(){
  No* raiz = criarArvore();
  inserirDado(&raiz,50);
  inserirDado(&raiz,25);
  inserirDado(&raiz,75);
  inserirDado(&raiz,5);
  exibirNo(raiz);
  //free(raiz);
  //system("echo 'digraph G {a->b; a->c;b->d;}' | dot -Tpng >teste.png");
  buscarDado(&raiz,25);
  int altura;
  altura = alturaArvore(&raiz);
  printf("Haltura da Arvore = %d\n",halturaArvore);
}
Vanderson11 commented 4 years ago

Vanderson leite campos

include

include

int altura = 0;

typedef struct No {

int dado;
struct No* direita;
struct No* esquerda;

} No;

No* criarArvore() {

return NULL;

}

int NoVazia(No* raiz) {

return raiz == NULL;

}

void exibirNo(No* raiz) {

if (!NoVazia(raiz)) { 
    printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
    exibirNo(raiz->esquerda); 
    exibirNo(raiz->direita); 
}

}

void buscar(No* raiz, int dado) {

if (!NoVazia(raiz)) {
    if (dado <= raiz->dado) {
        if (dado == raiz->dado) {
            printf("A busca foi: %p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
            return;
        } else {
            buscar(raiz->esquerda, dado);
        }
    }
    if (dado > (raiz->dado)) {
        if (dado == raiz->dado) {
            printf("A busca foi: %p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
            return;
        } else {
            buscar(raiz->direita, dado);
        }

    }
} else {
    printf("Nao encontrou nada!\n");
}

}

void inserirDado(No** raiz, int dado) {

if (*raiz == NULL) {
    *raiz = (No*) malloc(sizeof (No));
    (*raiz)->esquerda = NULL;
    (*raiz)->direita = NULL;
    (*raiz)->dado = dado;
} else {
    if (dado < (*raiz)->dado) { 

        inserirDado(&(*raiz)->esquerda, dado);
    }
    if (dado > (*raiz)->dado) {

        inserirDado(&(*raiz)->direita, dado);
    }
}

}

void altura(No** raiz){

if(*raiz != NULL)
{
    altura++;

    if((*raiz)->esquerda->dado != NULL && (*raiz)->direita->dado != NULL ) 
    {
        altura--;
        altura((*raiz)->esquerda);
        altura((*raiz)->direita);
    }
    else if((*raiz)->esquerda->dado != NULL && (*raiz)->direita->dado == NULL )
        altura((*raiz)->esquerda);

    else if( (*raiz)->esquerda->dado == NULL && (*raiz)->direita->dado != NULL )
        altura((*raiz)->direita);
}

}

void main() {

No* raiz = criarArvore();
inserirDado(&raiz, 50);
inserirDado(&raiz, 25);
inserirDado(&raiz, 75);
inserirDado(&raiz, 5);
exibirNo(raiz);

buscar(raiz, 750);

altura(&raiz);
printf("A altura é: %d\n", altura);

free(raiz);

system("echo 'digraph G {a->b; a->c;b->d;}' | dot -Tpng >teste.png");

}

dyegolv commented 4 years ago

Dyego Lima

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

typedef struct No{
  int dado;
  struct No* direita;
  struct No* esquerda;
} No;

No* criarArvore(){
  return NULL;
}

int NoVazia(No* raiz){
  // 1 se a arvore for vazia
  // 0 caso contrario 
  return raiz == NULL;
}

void exibirNo(No* raiz){
  if(!NoVazia(raiz)){ //No nao vazio
    printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
    exibirNo(raiz->esquerda);//esquerda (subNo)
    exibirNo(raiz->direita); //direita (subNo)
  }
}

void buscar(No** raiz, int dado){
  if(!NoVazia(*raiz)){ //No nao vazio
    if(dado == (*raiz)->dado){
      printf("%d encontrado.\n", dado);
      return;
    }
    else{
        if((*raiz)-> dado > dado){
        buscar(&(*raiz)->esquerda, dado);
        } else {
        buscar(&(*raiz)->direita, dado);
    }
    }
  }
}

void inserirDado(No** raiz, int dado){
    if(*raiz == NULL){
      *raiz = (No*)malloc(sizeof(No));
      (*raiz)->esquerda = NULL; 
      (*raiz)->direita = NULL; 
      (*raiz)->dado = dado; 
    } else {
        if(dado < (*raiz)->dado){ //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if(dado > (*raiz)->dado){ //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

int altura (No** raiz, int dado, No* r) {
   if (!NoVazia (*raiz) == NULL) 
      return -1; // altura da árvore vazia
   else {
      int hesq = altura (r->esquerda);
      int hdir = altura (r->direita);
      if (hesq < hdir) return hdir + 1;
      else return hesq + 1;
   }
}

int main(){
  No* raiz = criarArvore();
  for (int i = 0; i < 10; i++) {
    inserirDado(&raiz, rand() % 20); 
  }
  exibirNo(raiz); 
  buscar(&raiz, 10);
  free(raiz);
  return 0;
}
Tainara-Ataides commented 4 years ago

Tainara Moura De Ataídes

include

include

typedef struct No{ int dado; struct No direita; struct No esquerda; } No;

No* criarArvore(){ return NULL; }

int NoVazia(No* raiz){ // 1 se a arvore vazia, 0 caso contrario return raiz == NULL; }

int getValor(No* no){ if ((no) != NULL){ return (*no)->dado; } }

void mostrarArvore(No* raiz){ if(!NoVazia(raiz)){ //No nao vazio printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); printf("%d", getValor(&raiz->esquerda)); mostrarArvore(raiz->esquerda);//esquerda (subNo) mostrarArvore(raiz->direita); //direita (subNo) } }

void buscarDado(No* raiz, int dado){ if(!NoVazia(raiz)){ //No nao vazio if(dado == (raiz)->dado){ printf("%d encontrado.\n", dado); return; } else{ if(dado < (raiz)->dado){ //dado menor? vai pra esquerda buscarDado(&(raiz)->esquerda, dado); } if(dado > (raiz)->dado){ //dado maior? vai pra direita buscarDado(&(*raiz)->direita, dado); } } }

void altura(int maior, int menor){ if(maior>menor){ return maior; else retur menor; } int altura (No *1Raiz){ if(1Raiz == NULL) || (1Raiz->esquerda == NULL && 1Raiz->direita==NULL) return 0; }

} }

void inserirDado(No* raiz, int dado){ if(raiz == NULL){ raiz = (No)malloc(sizeof(No)); (raiz)->esquerda = NULL; (raiz)->direita = NULL; (raiz)->dado = dado; } else { if(dado < (raiz)->dado){ //dado menor? vai pra esquerda //percorrer subNo da esquerda inserirDado(&(raiz)->esquerda, dado); } if(dado > (raiz)->dado){ //dado maior? vai pra direita //percorrer subNo da direita inserirDado(&(raiz)->direita, dado); } } } void main(){ No raiz = criarArvore(); for (int i = 0; i < 100; i++) { inserirDado(&raiz, rand() % 200); }

jvitor7085 commented 4 years ago

José Vitor

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

typedef struct No{
  int dado;
  struct No* direita;
  struct No* esquerda;
} No;

No* criarArvore(){
  return NULL;
}

int NoVazia(No* raiz){
  // 1 se a arvore for vazia
  // 0 caso contrario
  return raiz == NULL;
}

void exibirNo(No* raiz){
  if(!NoVazia(raiz)){ //No nao vazio
    printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
    exibirNo(raiz->esquerda);//esquerda (subNo)
    exibirNo(raiz->direita); //direita (subNo)
  }
}

void inserirDado(No** raiz, int dado){
    if(*raiz == NULL){
      *raiz = (No*)malloc(sizeof(No));
      (*raiz)->esquerda = NULL;
      (*raiz)->direita = NULL;
      (*raiz)->dado = dado;
    } else {
        if(dado < (*raiz)->dado){ //dado menor? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if(dado > (*raiz)->dado){ //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

void buscaBinaria(No** raiz,int dado){
if((*raiz)->dado==dado){
   printf("    dado %d encontrado ",dado);
   return;
}else{
if(dado < (*raiz)->dado){
            buscaBinaria(&(*raiz)->esquerda, dado);}

if(dado > (*raiz)->dado){
            buscaBinaria(&(*raiz)->direita, dado);}
}
}
int altura(No** raiz){

if (*raiz == NULL)
      return -1; // altura da árvore vazia
   else {
      int altEs,altDir;

//esquerda nula
      if(altura(&((*raiz)->esquerda))==NULL &&altura(&((*raiz)->direita))!=NULL){
        altDir++;
        }
      if(altura(&((*raiz)->esquerda))!=NULL &&altura(&((*raiz)->direita))==NULL){
        altEs++;
        }
//os dois lados nulos
      if(altura(&((*raiz)->esquerda))==NULL &&altura(&((*raiz)->direita))==NULL){

        }
//nenhum lado nulo
      if(altura(&((*raiz)->esquerda))!=NULL &&altura(&((*raiz)->direita))!=NULL){
        altEs++;
        altDir++;

      if (altDir > altEs)
      return altDir ++;

      else
      return altEs ++;
   }
}
int altitude(){
return altitude(raiz);

}

void main(){
  No* raiz = criarArvore();
  inserirDado(&raiz, 50);
  inserirDado(&raiz, 25);
  inserirDado(&raiz, 75);
  inserirDado(&raiz, 5);
  exibirNo(raiz);
  free(raiz);
  printf("\n--------------------------\n");
  buscaBinaria(&raiz,25);
  printf("\n--------------------------\n");
  altura(&raiz);
}
LarissaJacobina commented 4 years ago

Larissa Jacobina

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

typedef struct No {
    int dado;
    struct No* direita;
    struct No* esquerda;
} No;

No* criarArvore() {
    return NULL;
}

int NoVazia(No* raiz) {
    // 1 se a arvore for vazia
    // 0 caso contrario 
    return raiz == NULL;
}

void exibirNo(No* raiz) {
    if (!NoVazia(raiz)) { //No nao vazio
        printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita);
        exibirNo(raiz->esquerda); //esquerda (subNo)
        exibirNo(raiz->direita); //direita (subNo)
    }
}

void inserirDado(No** raiz, int dado) {
    if (*raiz == NULL) {
        *raiz = (No*) malloc(sizeof (No));
        (*raiz)->esquerda = NULL;
        (*raiz)->direita = NULL;
        (*raiz)->dado = dado;
    } else {
        if (dado < (*raiz)->dado) { //dado men(*raiz)->or? vai pra esquerda
            //percorrer subNo da esquerda
            inserirDado(&(*raiz)->esquerda, dado);
        }
        if (dado > (*raiz)->dado) { //dado maior? vai pra direita
            //percorrer subNo da direita
            inserirDado(&(*raiz)->direita, dado);
        }
    }
}

void buscar(No** raiz, int dado) {
    if (!NoVazia(*raiz)) { //No nao vazio
        if (dado == (*raiz)->dado) {
            printf("%d encontrado.\n", dado);
            return;
        } else {
            if (dado < (*raiz)->dado) { //dado menor? vai pra esquerda
                buscar(&(*raiz)->esquerda, dado);
            }
            if (dado > (*raiz)->dado) { //dado maior? vai pra direita
                buscar(&(*raiz)->direita, dado);
            }
        }
    }
}

int altura(No* raiz) {
    if (raiz == NULL)
        return 0;
    else {
        int ae = altura(raiz->esquerda);
        int ad = altura(raiz->direita);
        if (ae < ad) {
            return ad + 1;
        } else {
            return ae + 1;
        }
    }
}

void imprimirAltura(No* raiz) {
    printf("Altura = %d\n", altura(raiz));
}

void main() {
    No* raiz = criarArvore();
    for (int i = 0; i < 20; i++) {
        inserirDado(&raiz, rand() % 21);
    }
    exibirNo(raiz);
    buscar(&raiz, 7);
    imprimirAltura(raiz);
    free(raiz);

}
gearle01 commented 4 years ago

include

include

int altura = 0;

typedef struct No {

int dado; struct No direita; struct No esquerda; } No;

No* criarArvore() {

return NULL; }

int NoVazia(No* raiz) {

return raiz == NULL; }

void exibirNo(No* raiz) {

if (!NoVazia(raiz)) { printf("%p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); exibirNo(raiz->esquerda); exibirNo(raiz->direita); } }

void buscar(No* raiz, int dado) {

if (!NoVazia(raiz)) { if (dado <= raiz->dado) { if (dado == raiz->dado) { printf("A busca foi: %p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); return; } else { buscar(raiz->esquerda, dado); } } if (dado > (raiz->dado)) { if (dado == raiz->dado) { printf("A busca foi: %p<-%d(%p)->%p\n\n", raiz->esquerda, raiz->dado, raiz, raiz->direita); return; } else { buscar(raiz->direita, dado); }

}

} else { printf("Nada por aqui!\n"); } }

void inserirDado(No** raiz, int dado) {

if (raiz == NULL) { raiz = (No) malloc(sizeof (No)); (raiz)->esquerda = NULL; (raiz)->direita = NULL; (raiz)->dado = dado; } else { if (dado < (*raiz)->dado) { 

    inserirDado(&(*raiz)->esquerda, dado);
}
if (dado > (*raiz)->dado) {

    inserirDado(&(*raiz)->direita, dado);
}

} }

void altura(No** raiz){

if(*raiz != NULL) { altura++;

if((*raiz)->esquerda->dado != NULL && (*raiz)->direita->dado != NULL ) 
{
    altura--;
    altura((*raiz)->esquerda);
    altura((*raiz)->direita);
}
else if((*raiz)->esquerda->dado != NULL && (*raiz)->direita->dado == NULL )
    altura((*raiz)->esquerda);

else if( (*raiz)->esquerda->dado == NULL && (*raiz)->direita->dado != NULL )
    altura((*raiz)->direita);

} }

void main() {

No* raiz = criarArvore(); inserirDado(&raiz, 50); inserirDado(&raiz, 25); inserirDado(&raiz, 75); inserirDado(&raiz, 5); exibirNo(raiz);

buscar(raiz, 5);

altura(&raiz); printf("A altura é: %d\n", altura);

free(raiz) }