A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Prof. Hilton Cardoso Marins Junior ÁRVORES BINÁRIAS.

Apresentações semelhantes


Apresentação em tema: "Prof. Hilton Cardoso Marins Junior ÁRVORES BINÁRIAS."— Transcrição da apresentação:

1 Prof. Hilton Cardoso Marins Junior hiltonmarins@gmail.com ÁRVORES BINÁRIAS

2 Á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.

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

4 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.

5 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.

6 Á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 = 1 2 1 = 2 2 2 = 4 2 3 = 8

7 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 01342 1316 22571 312 41053 52 629 720 13 10 25 31 12 20 2 2 29

8 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

9 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.

10 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);

11 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 7 2 2 4 4 Não haverá saída!

12 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

13 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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

25 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

26 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

27 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

28 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

29 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

30 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

31 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 1 1 2 2 3 3 7 7 5 5 6 6 4 4

32 Exemplo Usando as funções inicializa() e criaNo(), crie uma estrutura que represente a seguinte árvore: 1 1 2 2 3 3 6 6 4 4 5 5

33 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); 1 1 2 2 3 3 6 6 4 4 5 5

34 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1, 2, 4, 5, 3, 6 e 7

35 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a

36 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; }

37 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 1

38 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 1

39 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 12

40 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 12

41 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 124

42 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 124 null

43 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 124 null

44 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 a a 124

45 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a null

46 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a null

47 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a

48 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a

49 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a

50 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124 a a

51 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

52 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a null

53 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a null

54 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

55 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a null

56 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a null

57 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 */ } } } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

58 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 */ } }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

59 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 */ } } } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

60 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

61 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

62 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245 a a

63 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 12453 a a

64 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 12453 a a

65 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

66 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a null

67 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a null

68 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

69 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a null

70 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a null

71 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

72 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

73 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

74 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 124536 a a

75 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

76 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a null

77 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a null

78 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

79 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a null

80 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a null

81 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

82 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

83 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

84 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

85 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 */ } 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a

86 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 */ }} 1 1 2 2 3 3 7 7 5 5 6 6 4 4 1245367 a a Fim! Volta para a chamada externa.

87 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.

88 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).

89 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

90 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

91 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 */ }

92 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

93 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 */ }

94 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

95 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 */ }

96 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. 20 10 30 9 9 6 6 18 14 25 33 8 8 15

97 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 20. 20 10 30 9 9 6 6 18 14 25 33 8 8 15

98 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

99 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

100 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


Carregar ppt "Prof. Hilton Cardoso Marins Junior ÁRVORES BINÁRIAS."

Apresentações semelhantes


Anúncios Google