Árvores: Conceitos e binárias

1,429
-1

Published on

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,429
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
60
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Árvores: Conceitos e binárias

  1. 1. Árvores - Conceitos e binária Prof: Sergio Souza Costa
  2. 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. 3. Árvores Conceitos
  4. 4. Árvores • Estrutura não linear • Hieráquica • Recursiva
  5. 5. Árvores • Nodos interligados de maneira hierárquica • Nodo superior (raiz / pai), apontando para os seus nodos filhos (folhas / filho).
  6. 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. 7. Mais exemplos Estrutura de um arquivo HTML
  8. 8. Mais exemplos Hierarquia de diretorios e arquivos
  9. 9. Representação
  10. 10. Tipos de nodos (nós) raiz nodos interno folha
  11. 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. 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. 13. Esquema Geral raiz R Subárvores ...
  14. 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. 15. Exemplo
  16. 16. Exemplo
  17. 17. Exemplo
  18. 18. Exemplos de árvores
  19. 19. Caminho em árvore Sequencia de nodos ligando dois outros nodos quaisquer.
  20. 20. Caminho em árvore • Nota: Só existe um caminho desde a raiz até um determinado nó.
  21. 21. Altura de uma árvore • Altura é o tamanho do maior caminho desde a raiz até uma folha
  22. 22. Altura de uma árvore altura 3 altura 2 altura 1 altura 0
  23. 23. Altura de uma árvore • A altura da raiz é 0. • Por definição, a altura de uma árvore vazia é -1.
  24. 24. Grau de uma árvore • O grau de uma árvore é dado pela quantidade de descendentes permitido a cada nodo.
  25. 25. Exemplo de árvore de grau 4
  26. 26. Exemplo de árvore de grau 2 + 1 * 6 2
  27. 27. Árvores Binárias
  28. 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. 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. 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. 31. Exemplo Chaves de campeonatos
  32. 32. ÁRVORE BINÁRIA - EXEMPLO Chaves de campeonatos
  33. 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. 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. 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. 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. 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. 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. 39. Percurso em Árvores
  40. 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. 41. Exemplo de percurso pré-ordem + 1 * 6 +1*62 2
  42. 42. Exemplo de percurso em-ordem + 1 * 6 1+6*2 2
  43. 43. Exemplo de percurso pós-ordem + 1 * 6 162*+ 2
  44. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 64. Codificação • A árvore binária é representado pela estrutura abaixo. typedef struct ArvBin { int elem; struct ArvBin *sae; struct ArvBin *sad; } ArvBin;
  65. 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. 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. 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. 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. 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. 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. 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. 72. Visualização r 23 35 15 28
  73. 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. 74. Árvore Binária De Busca • Operações básicas – Insere elemento – Busca – Remoção
  75. 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. 76. Inserir Inserir 23
  77. 77. Inserir Inserir 23 23
  78. 78. Inserir Inserir 23 23 nil nil
  79. 79. Inserir Inserir 23 Inserir 15 23 nil nil
  80. 80. Inserir Inserir 23 Inserir 15 23 nil 15 nil
  81. 81. Inserir Inserir 23 Inserir 15 23 nil 15 nil nil nil
  82. 82. Inserir Inserir 23 Inserir 15 23 nil 15 nil nil
  83. 83. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 15 nil nil
  84. 84. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 35 15 nil nil
  85. 85. Inserir Inserir 23 Inserir 15 Inserir 35 23 nil 35 15 nil nil nil nil
  86. 86. Inserir Inserir 23 Inserir 15 Inserir 35 23 35 15 nil nil nil nil
  87. 87. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil nil
  88. 88. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil
  89. 89. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil nil nil
  90. 90. Inserir Inserir 23 Inserir 15 Inserir 35 Inserir 28 23 35 15 nil nil nil 28 nil nil
  91. 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. 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. 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. 94. Buscar Há um 28 armazenado? 23 35 15 nil nil nil 28 nil nil
  95. 95. Buscar 28 > 23 Há um 28 armazenado? 23 35 15 nil nil nil 28 nil nil
  96. 96. Buscar Há um 28 armazenado? 23 28 < 35 35 15 nil nil nil 28 nil nil
  97. 97. Buscar Há um 28 armazenado? 23 35 15 nil nil nil 28 nil encontrou nil
  98. 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.
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×