Carregar apresentação
A apresentação está carregando. Por favor, espere
PublicouLuísa Monterroso Alterado mais de 9 anos atrás
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
Apresentações semelhantes
© 2024 SlidePlayer.com.br Inc.
All rights reserved.