Prof. Hilton Cardoso Marins Junior ÁRVORES BINÁRIAS

Árvores Binárias São estruturas do tipo árvore, onde o grau de cada nó é menor ou igual a 2. Quando o grau do nó for igual a 2 temos a subárvore a direita (sad) e a subárvore a esquerda (sae), quando o grau do nó for igual a 1 temos uma subárvore direita ou uma subárvore esquerda e se o grau do nó for igual a 0 não temos subárvores. Aplicação: Representação de expressões aritméticas de tal forma que a hierarquia dos operadores fique clara. Em operações de ordenação.

Exemplo de Árvore Binária A expressão (a * b) + (c / (d + e)) poderia ser representada da seguinte forma:

Definição T Uma árvore binária T é um conjunto finito de elementos denominados nós ou vértices, tal que: T = Ø T = Ø e a árvore é dita vazia, ou rT T r L T r R r Existe um nó especial r, chamado raiz de T, e os restantes podem ser divididos em dois subconjuntos disjuntos, T r L e T r R a subárvore esquerda e a direita de r, respectivamente, as quais são também árvores binárias.

Tipos de Árvores Binárias Árvore estritamente binária Árvore estritamente binária: Cada nó possui 0 ou 2 filhos. Árvore binária completa Árvore binária completa: Se v é um nó tal que alguma subárvore de v é vazia, então v se localiza ou no último (maior) ou no penúltimo nível da árvore. Árvore binária cheia Árvore binária cheia: Se v é um nó tal que alguma subárvore de v é vazia, então v se localiza no último (maior) nível da árvore. v é um nó folha.

Árvore Binária Em uma árvore binária cheia o número de nós do nível i é igual a 2 i. Consequentemente, em qualquer árvore binária existe no máximo 2 i nós no nível i. 2 0 = = = = 8

Representação de uma Árvore Binária por Contiguidade saesad O nó será uma estrutura com um campo de informação e duas referências, uma para a sae (subárvore esquerda) e outra para a sad (subárvore direita). A Raiz localiza-se na primeira célula (índice 0) -1 indica filho nulo ÍndiceInformaçãosaesad

Representação de uma Árvore Binária por Encadeamento O nó é formado por uma estrutura composta de: Campo de informação Ponteiro para sae. Ponteiro para sad. saeinfosad A saeinfosad Bnull saeinfosad C saeinfosad nullD saeinfosad E saeinfosad nullF saeinfosad nullH saeinfosad nullI saeinfosad nullG

Operações com Árvore Binária por Encadeamento Para exemplificarmos operações com uma árvore binária por encadeamento utilizaremos a definição abaixo: struct TipoArvore { int info; struct TipoArvore* sae; struct TipoArvore* sad; }; typedef struct TipoArvore Arvore; Trata-se de uma árvore binária encadeada de números inteiros, todos os exemplos podem ser adaptados para qualquer outro tipo de dado básico ou estruturado.

Operações com Árvore Binária por Encadeamento //cria uma árvore vazia Arvore* inicializa(); //verifica se a arvore está vazia int estaVazia(Arvore* a); //cria um nó, dado a informação e as duas subárvores Arvore* criaNo(int n, Arvore* sae, Arvore* sad); //libera a estrutura da árvore Arvore* libera(Arvore* a); //Determinar se uma informação se encontra ou não na árvore int busca(Arvore* a, int n); //imprime a informação de todos os nós da árvore void imprime(Arvore* a); //Determinar a altura de uma árvore int getAltura(Arvore* a); //Contar quantas são as folhas de uma árvore int getfolhas(Arvore* a);

O programa principal int main(){ Arvore *D = criaNo(4, inicializa(), inicializa()); Arvore *E = criaNo(5, inicializa(), inicializa()); Arvore *F = criaNo(6, inicializa(), inicializa()); Arvore *G = criaNo(7, inicializa(), inicializa()); Arvore *B = criaNo(2, D, E); Arvore *C = criaNo(3, F, G); Arvore *A = criaNo(1, B, C); imprime(A); printf("\nAltura da arvore = %d", getAltura(A)); if (!busca(A, 113)){ printf("\nInformacao INEXISTENTE!"); }else{ printf("\nInformacao ENCONTRADA COM SUCESSO!"); } printf("\nQuantidade de folhas = %d", getFolhas(A)); A = libera(A); imprime(A); return 0; } 1, 2, 4, 5, 3, 6 e Não haverá saída!

Analisando a chamada da função main: inicializa()inicializa() Arvore *D = criaNo(4, inicializa(), inicializa()); /* cria uma árvore vazia. */ Arvore* inicializa(){ return NULL; } /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } null

Analisando a chamada da função main: Arvore *D = criaNo(4, inicializa(), inicializa()); /* cria uma árvore vazia. */ Arvore* inicializa(){ return NULL; } /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } saeinfosad null p p

Analisando a chamada da função main: Arvore *D = criaNo(4, inicializa(), inicializa()); /* cria uma árvore vazia. */ Arvore* inicializa(){ return NULL; } /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sae = sae; p->sad = sad; p->sad = sad; return p; } null saeinfosad null4 p p

Analisando a chamada da função main: Arvore *D = criaNo(4, inicializa(), inicializa()); /* cria uma árvore vazia. */ Arvore* inicializa(){ return NULL; } /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; return p; } null saeinfosad null4 D D

Analisando a chamada da função main: Arvore *E = criaNo(5, inicializa(), inicializa()); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; } saeinfosad null4 D D saeinfosad null5 E E

Analisando a chamada da função main: Arvore *F = criaNo(6, inicializa(), inicializa()); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; } saeinfosad null4 D D saeinfosad null5 E E saeinfosad null6 F F

Analisando a chamada da função main: Arvore *G = criaNo(7, inicializa(), inicializa()); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; } saeinfosad null4 D D saeinfosad null5 E E saeinfosad null6 F F saeinfosad null7 G G

Analisando a chamada da função main: Arvore *B = criaNo(2, D, E); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; } saeinfosad null4 D D saeinfosad null5 E E saeinfosad null6 F F saeinfosad null7 G G

Analisando a chamada da função main: Arvore *B = criaNo(2, D, E); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; ; p->sad = sad; return p; } saeinfosad null4 D D saeinfosad null5 E E saeinfosad null6 F F saeinfosad null7 G G saeinfosad null p p

Analisando a chamada da função main: Arvore *B = criaNo(2, D, E); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sae = sae; p->sad = sad; p->sad = sad; return p; } saeinfosad null4 saeinfosad null5 saeinfosad null6 F F saeinfosad null7 G G saeinfosad 2 p p D D E E

Analisando a chamada da função main: Arvore *B = criaNo(2, D, E); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E

Analisando a chamada da função main: Arvore *C = criaNo(3, F, G); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E

Analisando a chamada da função main: Arvore *C = criaNo(3, F, G); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad null p p

Analisando a chamada da função main: Arvore *C = criaNo(3, F, G); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->info = n; p->sae = sae; p->sae = sae; p->sad = sad; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 p p

Analisando a chamada da função main: Arvore *C = criaNo(3, F, G); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C

Analisando a chamada da função main: Arvore *A = criaNo(1, B, C); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C

Analisando a chamada da função main: Arvore *A = criaNo(1, B, C); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C saeinfosad null p p

Analisando a chamada da função main: Arvore *A = criaNo(1, B, C); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->info = n; p->sae = sae; p->sae = sae; p->sad = sad; p->sad = sad; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C saeinfosad 1 p p

Analisando a chamada da função main: Arvore *A = criaNo(1, B, C); /* cria um nó com a informação, a sae e a sad. */ Arvore* criaNo(int n, Arvore* sae, Arvore* sad){ Arvore* p = (Arvore*) malloc(sizeof(Arvore)); p->info = n; p->sae = sae; p->sad = sad; return p; return p; } saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C saeinfosad 1 A A

Configuração da Árvore até o momento saeinfosad null6 F F saeinfosad null7 G G saeinfosad null4 saeinfosad null5 saeinfosad 2 B B D D E E saeinfosad 3 C C saeinfosad 1 A A

Exemplo Usando as funções inicializa() e criaNo(), crie uma estrutura que represente a seguinte árvore:

Exemplo Usando as funções inicializa() e criaNo(), crie uma estrutura que represente a seguinte árvore : Arvore *D = criaNo(4, inicializa(), inicializa()); Arvore *E = criaNo(5, inicializa(), inicializa()); Arvore *F = criaNo(6, inicializa(), inicializa()); Arvore *B = criaNo(2, inicializa(), D); Arvore *C = criaNo(3, E, F); Arvore *A = criaNo(1, B, C);

Analisando a chamada da função main:imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } , 2, 4, 5, 3, 6 e 7

Analisando a chamada da função main:imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } /* verifica se a arvore está vazia. */ int estaVazia(Arvore* a){ return a == NULL; } /* verifica se a arvore está vazia. */ int estaVazia(Arvore* a){ return a == NULL; }

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 1

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 1

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 12

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 12

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 124

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 124 null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a 124 null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a 124

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } } } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } } } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae * imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ Arvore* a void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ imprime(a->sad); /* mostra sad */ } a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ !estaVazia(a) if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a null

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a

Analisando a chamada da função main: imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ } a a

Analisando a chamada da função main:imprime(A); /* imprime a informação de todos os nós da árvore. */ void imprime(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprime(a->sae); /* mostra sae */ imprime(a->sad); /* mostra sad */ }} a a Fim! Volta para a chamada externa.

Percurso em Árvores Binárias Uma das operações básicas relativas à manipulação de árvores é a visita sistemática a cada um dos seus nós. Para percorrer a árvore deve-se, então, visitar cada um de seus nós. Visitar um nó significa operar com a informação do nó. Por exemplo: imprimir (conforme analisado anteriormente), atualizar informações, etc.

Percurso em Árvores Binárias Temos duas categorias de percurso: Percurso em profundidade Percurso em profundidade: Corresponde a visitar um nó raiz e explora tanto quanto possível cada um dos seus ramos, antes de retroceder. Percurso em largura: Percurso em largura: Corresponde a visitar cada nó começando o nível mais baixo (ou mais alto) e movendo para baixo (ou para cima) nível a nível, visitando nós em cada nível da esquerda para direita (ou da direita para a esquerda).

Percurso em ProfundidadePré-ordem: Visitar a raiz Percorrer a sub-árvore esquerda em pré-ordem Percorrer a sub-árvore direita em pré-ordemIn-ordem: Percorrer a sub-árvore esquerda em in-ordem Visitar a raiz Percorrer a sub-árvore direita em in-ordemPós-ordem: Percorrer a sub-árvore esquerda em pós-ordem Percorrer a sub-árvore direita em pós-ordem Visitar a raiz

Pré-Ordem Percurso em Profundidade: Pré-Ordem Visitar a raiz Percorrer a sub-árvore esquerda em pré-ordem Percorrer a sub-árvore direita em pré-ordem Percurso: A B D G C E H I F * A função Imprime analisada anteriormente usou o percurso Pré-Ordem. A A B B C C F F G G E E D D I I H H

Pré-Ordem Percurso em Profundidade: Pré-Ordem Visitar a raiz Percorrer a sub-árvore esquerda em pré-ordem Percorrer a sub-árvore direita em pré-ordem /* imprime todos os nós da árvore em Pre-Ordem. */ void imprimePre(Arvore* a){ if(!estaVazia(a)){ printf("%d ", a->info); /* mostra raiz */ imprimePre(a->sae); /* mostra sae */ imprimePre(a->sad); /* mostra sad */ }

n-Ordem Percurso em Profundidade: In-Ordem Percorrer a sub-árvore esquerda em in-ordem Visitar a raiz Percorrer a sub-árvore direita em in-ordem Percurso: D G B A H E I C F A A B B C C F F G G E E D D I I H H

n-Ordem Percurso em Profundidade: In-Ordem Percorrer a sub-árvore esquerda em in-ordem Visitar a raiz Percorrer a sub-árvore direita em in-ordem /* imprime todos os nós da árvore em In-Ordem. */ void imprimeIn(Arvore* a){ if(!estaVazia(a)){ imprimeIn(a->sae); /* mostra sae */ printf("%d ", a->info); /* mostra raiz */ imprimeIn(a->sad); /* mostra sad */ }

Pós-Ordem Percurso em Profundidade: Pós-Ordem Percorrer a sub-árvore esquerda em pós-ordem Percorrer a sub-árvore direita em pós-ordem Visitar a raiz Percurso: G D B H I E F C A A A B B C C F F G G E E D D I I H H

Pós-Ordem Percurso em Profundidade: Pós-Ordem Percorrer a sub-árvore esquerda em pós-ordem Percorrer a sub-árvore direita em pós-ordem Visitar a raiz /* imprime todos os nós da árvore em Pos-Ordem. */ void imprimePos(Arvore* a){ if(!estaVazia(a)){ imprimePos(a->sae); /* mostra sae */ imprimePos(a->sad); /* mostra sad */ printf("%d ", a->info); /* mostra raiz */ }

Exercícios de Percurso em Profundidade 1. Usando as funções inicializa() e criaNo(), crie uma estrutura que represente a seguinte árvore: 2. Indique o percurso em pré-ordem, in-ordem e pós-ordem

Exercícios de Percurso em Profundidade Arvore *H = criaNo(6, inicializa(), inicializa()); Arvore *I = criaNo(9, inicializa(), inicializa()); Arvore *J = criaNo(14, inicializa(), inicializa()); Arvore *K = criaNo(18, inicializa(), inicializa()); Arvore *D = criaNo(8, H, I); Arvore *E = criaNo(15, J, K); Arvore *F = criaNo(25, inicializa(), inicializa()); Arvore *G = criaNo(33, inicializa(), inicializa()); Arvore *B = criaNo(10, D, E); Arvore *C = criaNo(30, F, G); Arvore *A = criaNo(20, B, C); Pré-Ordem:20, 10, 8, 6, 9, 15, 14, 18, 30, 25 e 33 In-Ordem:6, 8, 9, 10, 14, 15, 18, 20, 25, 30 e 33. Pós-Ordem:6, 9, 8, 14, 18, 15, 10, 25, 33, 30 e

Percurso em Largura Lembando: Corresponde a visitar cada nó começando o nível mais baixo (ou mais alto) e movendo para baixo (ou para cima) nível a nível, visitando nós em cada nível da esquerda para direita (ou da direita para a esquerda). Percurso: A, B, C, D, E, F, G, H e I A A B B C C F F G G E E D D I I H H

Percurso em Largura Para exemplificar, o percurso será de cima para baixo e da esquerda para direita usando uma fila: Quando um nó é visitado, seus filhos (se houver) são colocados no final da fila. Nó no início da fila é visitado. A A B B C C F F G G E E D D I I H H

Percurso em Largura ABC BC CD CD DEF Visita A – insere B e C na fila Visita B – insere D na fila Visita C – insere E e F na fila EFGVisita D – insere G na fila DEF FGHIVisita E – insere H e I na fila EFG GHIVisita F FGHI GHI Visita G HI HI Visita H I I Visita I A A B B C C F F G G E E D D I I H H FILA