Árvores:  Conceitos e binárias
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Árvores: Conceitos e binárias

on

  • 491 views

 

Statistics

Views

Total Views
491
Views on SlideShare
482
Embed Views
9

Actions

Likes
2
Downloads
37
Comments
0

1 Embed 9

https://mj89sp3sau2k7lj1eg3k40hkeppguj6j-a-sites-opensocial.googleusercontent.com 9

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Árvores: Conceitos e binárias Presentation Transcript

  • 1. Árvores - Conceitos e binária Prof: Sergio Souza Costa
  • 2. Sobre mim Sérgio Souza Costa Professor - UFMA Doutor em Computação Aplicada (INPE) prof.sergio.costa@gmail.com https://sites.google.com/site/profsergiocosta/home http://www.slideshare.net/skosta/presentations?order=popular https://twitter.com/profsergiocosta http://gplus.to/sergiosouzacosta
  • 3. Árvores Conceitos
  • 4. Árvores • Estrutura não linear • Hieráquica • Recursiva
  • 5. Árvores • Nodos interligados de maneira hierárquica • Nodo superior (raiz / pai), apontando para os seus nodos filhos (folhas / filho).
  • 6. Analogia no mundo real • Estrutura organizacional de uma empresa – Departamentos, setores, seções, etc. • Organização de um livro – Partes, capítulos, seções, parágrafos
  • 7. Mais exemplos Estrutura de um arquivo HTML
  • 8. Mais exemplos Hierarquia de diretorios e arquivos
  • 9. Representação
  • 10. Tipos de nodos (nós) raiz nodos interno folha
  • 11. Definições • Raíz: um nodo sem pai • Nodo: um elemento qualquer • Folha: um nó que possui grau zero, ou seja, suas subárvores são vázia. • Sub-árvore: formada por todos os nodos filhos a partir de um nodo qualquer
  • 12. Definição geral • Um nodo sem filhos e sem pai é uma árvore vazia. • Um nodo com qualquer número de subárvores descendentes é uma árvore
  • 13. Esquema Geral raiz R Subárvores ...
  • 14. Sub-árvores Sub-árvore: é aquela que se forma a partir de um determinado nó. A árvore A possui 2 subárvores: A = {B, C } Árvore C possui 3 subárvores: C = {D, E, F} Onde D = {G,H} F = {I}
  • 15. Exemplo
  • 16. Exemplo
  • 17. Exemplo
  • 18. Exemplos de árvores
  • 19. Caminho em árvore Sequencia de nodos ligando dois outros nodos quaisquer.
  • 20. Caminho em árvore • Nota: Só existe um caminho desde a raiz até um determinado nó.
  • 21. Altura de uma árvore • Altura é o tamanho do maior caminho desde a raiz até uma folha
  • 22. Altura de uma árvore altura 3 altura 2 altura 1 altura 0
  • 23. Altura de uma árvore • A altura da raiz é 0. • Por definição, a altura de uma árvore vazia é -1.
  • 24. Grau de uma árvore • O grau de uma árvore é dado pela quantidade de descendentes permitido a cada nodo.
  • 25. Exemplo de árvore de grau 4
  • 26. Exemplo de árvore de grau 2 + 1 * 6 2
  • 27. Árvores Binárias
  • 28. Árvores Binárias • Árvore binária é um caso especial de árvore em que nenhum nodo tem grau superior a 2, isto é, nenhum nodo tem mais que dois filhos. – Adicionalmente, para árvores binárias existe um "senso de posição", ou seja, distingue-se entre uma subárvore esquerda e uma direita. Exemplos a a b b a b c
  • 29. Árvores Binárias • Uma árvore binária é uma árvore que pode ser nula, ou então tem as seguintes características: – existe um nodo especial denominado raiz; – os demais nodos são particionados em T1, T2 estruturas disjuntas de árvores binárias; – T1 é denominada subárvore esquerda e T2, subárvore direita da raiz.
  • 30. Árvores Binárias • Uma árvore binária é uma árvore que pode ser nula, ou então tem as seguintes características: – existe um nodo especial denominado raiz; – os demais nodos são particionados em T1, T2 estruturas disjuntas de árvores binárias; – T1 é denominada subárvore esquerda e T2, subárvore direitaem a raiz. da Observ na sividade recur ição sua defin
  • 31. Exemplo Chaves de campeonatos
  • 32. ÁRVORE BINÁRIA - EXEMPLO Chaves de campeonatos
  • 33. Terminologias Árvore estritamente binária: cada nó tem grau 0 ou 2, ou seja, todo nó tem 0 ou 2 filho a) b)
  • 34. Terminologias Árvore estritamente binária: cada nó tem grau 0 ou 2, ou seja, todo nó tem 0 ou 2 filho a) b)
  • 35. Terminologias Árvore binária completa é uma árvore estritamente binária na qual todo nó que apresente alguma sub-árvore vazia está localizado no último ou no penúltimo nível da árvore a) b)
  • 36. Terminologias Árvore binária completa é uma árvore estritamente binária na qual todo nó que apresente alguma sub-árvore vazia está localizado no último ou no penúltimo nível da árvore a) b)
  • 37. Terminologias Árvore binária cheia quando todos os nós internos tem grau 2 e todas as folhas estão no mesmo nível a) b)
  • 38. Terminologias Árvore binária cheia quando todos os nós internos tem grau 2 e todas as folhas estão no mesmo nível a) b)
  • 39. Percurso em Árvores
  • 40. Percurso em árvore binária • Pré-ordem: visita a raiz, depois a sub-árvore da esquerda e depois direita. • Em-ordem: visita a sub-árvore esquerda, depois a raiz, e finalmente a sub-árvore direita. • Pós-ordem: visita a sub-árvore da esquerda, depois da direita e por ultimo imprime a raiz.
  • 41. Exemplo de percurso pré-ordem + 1 * 6 +1*62 2
  • 42. Exemplo de percurso em-ordem + 1 * 6 1+6*2 2
  • 43. Exemplo de percurso pós-ordem + 1 * 6 162*+ 2
  • 44. Exemplo de percurso pós-ordem + 1 * 6 o de algoritm Um pósercurso p nverte rdem co o infixa notação fixa para pos 162*+ 2
  • 45. Arvore Binária: TDA • Tipo de dados abstrato da árvore binária: Vazia: () → A // elemento, arvore esquerda direita Nodo: E × SAE × SAD → A
  • 46. Arvore Binária: TDA • Tipo de dados abstrato da árvore binária: Vazia: () → A // elemento, arvore esquerda direita Nodo: E × SAE × SAD → A Que árvore é essa ? A = Nodo (5, Vazia, Nodo (8, Nodo (4, Vazia, Vazia), Vazia)))
  • 47. Arvore Binária: TDA • Tipo de dados abstrato da árvore binária: Vazia: () → A // elemento, arvore esquerda direita Nodo: E × SAE × SAD → A Que árvore é essa ? A = Nodo (5, Vazia, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) 5 8 4 Árvore vazia
  • 48. Arvore Binária: TDA • Operações acessoras: sae:: A → A // retorna a subarvore esquerda sad:: A → A // retorna a subarvore direita element :: A → E // retorno o elemento do nó
  • 49. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A)
  • 50. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 8 4
  • 51. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 B 8 4
  • 52. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 C B 8 4
  • 53. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 C B 8 D 4
  • 54. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 C B 8 D 4
  • 55. Exercício A = Nodo (5, Nil, Nodo (8, Nodo (4, Vazia, Vazia), Vazia))) B = sae (A) C = sad (A) D = sae(C) X = element (D) Y = element (A) A 5 C B 8 D 4
  • 56. Exercícios resolvidos • Ainda sem codificar em C a nossa árvore, faremos os seguintes exercícios. • Podem fazer no papel ou bloco de notas, não precisem compilar (apenas mentalmente). • Usando recursividade e apenas as quatro operações vistas anteriormente, vamos fazer os seguintes exercícios.
  • 57. Exercícios resolvidos 1. Some os valores dos elementos de uma arvore binária int soma (ArvBin *a) { if (a == Vazia()) return 0; }
  • 58. Exercícios resolvidos 1. Some os valores dos elementos de uma arvore binária int soma (ArvBin *a) { if (a == Vazia()) return 0; return elem(a) + soma (sae(a)) + soma (sad(a)); }
  • 59. Exercícios resolvidos 1. Retorne a altura de uma árvore binaria. Onde a Altura é o tamanho do maior caminho desde a raiz até uma folha. Por definição, a altura de uma árvore vazia é -1. int altura(ArvBin *a) { }
  • 60. Exercícios resolvidos 1. Retorne a altura de uma árvore binaria. Onde a Altura é o tamanho do maior caminho desde a raiz até uma folha. Por definição, a altura de uma árvore vazia é -1. int altura(ArvBin *a) { if (a == Vazia()) return -1; }
  • 61. Exercícios resolvidos 1. Retorne a altura de uma árvore binaria. Onde a Altura é o tamanho do maior caminho desde a raiz até uma folha. Por definição, a altura de uma árvore vazia é -1. int altura(ArvBin *a) { if (a == Vazia()) return -1; return maior( altura (sae (a)), altura (sad (a)) ) + 1; }
  • 62. Exercícios resolvidos 1. Retorne a altura de uma árvore binaria. Onde a Altura é o tamanho do maior caminho desde a raiz até uma folha. Por definição, a altura de uma árvore vazia é -1. int altura(ArvBin *a) { if (a == Vazia()) return -1; return maior( altura (sae (a)), altura (sad (a)) ) + 1; }
  • 63. Exercícios resolvidos 1. Retorne a altura de uma árvore binaria. Onde a Altura é o tamanho do maior caminho desde a raiz até uma folha. Por definição, a altura de uma árvore vazia é -1. int maior (int v1, int v2) { int altura(ArvBin *a) { if if (a == Vazia())(v1 > v2) return -1; return v1 ; return maior(else return v2; } altura (sae (a)), altura (sad (a)) ) + 1; }
  • 64. Codificação • A árvore binária é representado pela estrutura abaixo. typedef struct ArvBin { int elem; struct ArvBin *sae; struct ArvBin *sad; } ArvBin;
  • 65. Codificação • Operações construtoras ArvBin* Vazia () { return NULL; } ArvBin* Nodo (int elem, ArvBin* sae, ArvBin* sad ) { ArvBin* a = (ArvBin*)malloc (sizeof (ArvBin)); a->elem = elem; a->sad = sad; a->sae = sae; return a; }
  • 66. Codificação • Operações construtoras ArvBin* Vazia () { return NULL; } ArvBin* Nodo (int elem, ArvBin* sae, ArvBin* sad ) { ArvBin* a = (ArvBin*)malloc (sizeof (ArvBin)); a->elem = elem; a->sad = sad; a->sae = sae; return a; }
  • 67. Codificação • Operações construtoras ArvBin* Vazia () { return NULL; } ArvBin* Nodo (int elem, ArvBin* sae, ArvBin* sad ) { ArvBin* a = (ArvBin*)malloc (sizeof (ArvBin)); a->elem = elem; a->sad = sad; a->sae = sae; return a; }
  • 68. Codificação • Operações construtoras ArvBin* Vazia () { return NULL; } ArvBin* Nodo (int elem, ArvBin* sae, ArvBin* sad ) { ArvBin* a = (ArvBin*)malloc (sizeof (ArvBin)); a->elem = elem; a->sad = sad; a->sae = sae; return a; }
  • 69. Codificação • Operações construtoras ArvBin* Vazia () { return NULL; } ArvBin* Nodo (int elem, ArvBin* sae, ArvBin* sad ) { ArvBin* a = (ArvBin*)malloc (sizeof (ArvBin)); a->elem = elem; a->sad = sad; a->sae = sae; return a; }
  • 70. Codificação • Operações retornar os atributos da árvore. int elem (ArvBin* b) { return b->elem;} ArvBin* sae (ArvBin* b) { return b->sae;} ArvBin* sad (ArvBin* b) { return b->sad;}
  • 71. Codificação • Código para visualizar uma árvore binária “deitada” void mostra (ArvBin *a, int n) { if (a) { int i; mostra (sad(a), n+1); for (i = 0; i < n; i++) printf ("t"); printf ("%dn", elem(a)); mostra (sae(a), n+1); } }
  • 72. Visualização r 23 35 15 28
  • 73. Árvore binária - Aplicações • Uma importante aplicação das árvores binárias é para a realização de buscas. • O que as árvores abaixo tem em comum? 13 K A 10 P 2 N 25 12 20 31 R 29
  • 74. Árvore Binária De Busca • Operações básicas – Insere elemento – Busca – Remoção
  • 75. INSERÇÃO • Para adicionar um elemento x – Se a árvore estiver vazia, adicione um novo nó contendo o elemento x – Se a raiz é maior que x então insira x na subárvore esquerda, caso contrário – insira x na subárvore direita
  • 76. Inserir Inserir 23
  • 77. Inserir Inserir 23 23
  • 78. Inserir Inserir 23 23 nil nil
  • 79. Inserir Inserir 23 Inserir 15 23 nil nil
  • 80. Inserir Inserir 23 Inserir 15 23 nil 15 nil
  • 81. Inserir Inserir 23 Inserir 15 23 nil 15 nil nil nil
  • 82. Inserir Inserir 23 Inserir 15 23 nil 15 nil nil
  • 83. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 15 nil nil
  • 84. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 35 15 nil nil
  • 85. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 35 15 nil nil nil nil
  • 86. Inserir Inserir 23 Inserir 15 Inserir 35 23 35 15 nil nil nil nil
  • 87. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil nil
  • 88. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil
  • 89. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil nil nil
  • 90. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil nil
  • 91. Inserir - Código ArvBin *insere (ArvBin *r, int x) { if (r == NULL) r = Nodo (x, NULL, NULL); else if (x < elem(r) ) r->sae = insere(sae(r), x ) ; else r->sad = insere(sad(r), x ) ; return r; }
  • 92. Testando - Inserir 23 35 15 nil arv = insere(arv, 23); arv = insere(arv, 15); arv = insere(arv, 35); arv = insere(arv, 28); nil nil 28 nil nil
  • 93. Busca • Para encontrar um elemento x – Se x é a raiz então x foi encontrado, caso contrário – Se x é menor que a raiz então procure x na sub-árvore esquerda, caso contrário – Procure x na sub-árvore direita de – Se a árvore é vazia então a busca falha
  • 94. Buscar Há um 28 armazenado? 23 35 15 nil nil nil 28 nil nil
  • 95. Buscar 28 > 23 Há um 28 armazenado? 23 35 15 nil nil nil 28 nil nil
  • 96. Buscar Há um 28 armazenado? 23 28 < 35 35 15 nil nil nil 28 nil nil
  • 97. Buscar Há um 28 armazenado? 23 35 15 nil nil nil 28 nil encontrou nil
  • 98. Código - Buscar ArvBin* busca (ArvBin *r, int x) { if ((!r) || (elem(r) == x)) return r; else { if (elem(r) < x) return busca(sad(r),x); else return busca(sae(r),x); } } Parada: Achou o elemento ou o elemento não se encontra na arvore.