O documento descreve árvores binárias de busca implementadas por encadeamento. Ele define classes Node e Tree que representam nós e árvores, respectivamente. A classe Tree contém métodos para inserir, buscar e remover nós na árvore de forma recursiva, mantendo a estrutura binária de busca.

1. Árvores
Python
George Maximiano Silvestre
Marcelo Rios Kwecko
Rafael Cemin

2. Introdução
• Constituem uma das estruturas mais importantes da área de
computação, inclusive em aplicações
▪ Relacionamento Lógico
▪ Hierarquia ou Subordinação
▪ Onde:
▪ um subconjunto dos componentes é subordinado a outro

3. Exemplos de Aplicações

4. Exemplos de Aplicações

5. Exemplos de Aplicações

6. Definição Formal
• Conjunto finito T de zero ou mais nós, tal que:
• número de nodos maior do que zero
• existe um nó denominado raiz da árvore
• os demais nós formam m > 0 conjuntos disjuntos S1, S2, ..., Sm, onde cada um destes é
uma árvore (Si são denominadas sub-árvores)
• número de nodos igual a zero
• árvore vazia

7. Terminologia

8. Terminologia
• Grau
• número de sub-árvores do nodo
• Grau de saída
• número de filhos de um nodo

9. Terminologia
• Grau de uma árvore
• máximo entre os graus de seus nodos

10. Terminologia
• Nó de derivação (interno)
• nó com grau maior do que zero

11. Terminologia
• Nó folha (ou terminal ou externo)
• grau igual a zero

12. Terminologia
• Caminho
• sequência de nodos distintos, tal que
existem sempre nodos consecutivos
• Comprimento do caminho
• sequência de nodos distintos, tal que
• existem sempre nodos consecutivos
• v1 alcança vk e vk é alcançado por v1

13. Terminologia
• Nível
• número de ligações entre o nodo e a raiz, acrescido de uma unidade

14. Terminologia
• Altura (profundidade)
• maior nível

15. Terminologia
• Árvore ordenada
• ordem das sub-árvores é relevante

16. Árvores Implementadas por
Contiguidade Física

17. Árvores – Contiguidade Física
• Os nodos da árvore são dispostos na memória segundo uma
convenção estabelecida

18. Árvores – Contiguidade Física
• várias formas
• definir uma estratégia
• conhecer a estratégia
para realizar
operações

19. Árvores – Contiguidade Física

20. Análise – Contiguidade Física
• não constitui, em geral, uma boa solução
• dificuldades para manipulação da estrutura (hierarquia)
• geralmente eficiente em termos de espaço ocupado

21. Árvores Implementadas por
Encadeamento

22. Árvores - Encadeamento

23. Árvores - Encadeamento
• Problema:
• árvore de grau arbitrário tem número elevado de campos ociosos

24. Análise – Encadeamento
• problemas quando grau dos nodos é variado – muitos elos vazios
• acesso somente através de raiz – disciplina para percorrer árvore
• inserção e remoção são simplificadas
• hierarquia é intuitiva

25. Referências
• Curso PCAP - Programming Essentials in Python, CISCO NetAcad
https://www.netacad.com

26. 27/07/2022 15:53
Arvore_Contiguidade.py
Página 1 de 4
http://localhost:4649/?mode=python
# Arvore Contiguidade
# Vetor Arvore
# Elementos não repetidos
# A # B E # C # D F | G /
V_Arvore = []
def Inserir():
global V_Arvore
# Adiciona o no raiz
if not V_Arvore:
print("Arvore vazia! Entre com o nó Raiz: ", end='')
V_Arvore.append(input())
V_Arvore.append("#")
return
# Adiciona quando so ha o nó RAIZ
if V_Arvore.count("#") == 1:
print("Entre com o elemento: ", end='')
V_Arvore.append(input())
V_Arvore.append("#")
return
# Adicionar um elemento na lista!
print(V_Arvore)
print("Informe o elemento pai deste: ", end='')
PAI = input()
if V_Arvore.count(PAI) == 0:
print("Elemento informado não está presente!")
return
# Obtem a posicao do PAI
P=V_Arvore.index(PAI)
# Ramificação do PAI
if P == 0:
print("Entre com o elemento: ", end='')
V_Arvore.append(input())
V_Arvore.append("#")
return
# No sem ramificaçao
if V_Arvore[P+1] == "#" or V_Arvore[P+1] == "|":
print("Entre com o elemento: ", end='')
V_Arvore.insert(P+1, input())
return
# Com Ramificacao
V_Arvore.insert(P+1, "|")
PT=V_Arvore.index("#",P)
V_Arvore.insert(PT, "|")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

27. 27/07/2022 15:53
Arvore_Contiguidade.py
Página 2 de 4
http://localhost:4649/?mode=python
V_Arvore.insert(PT, "|")
print("Entre com o elemento: ", end='')
V_Arvore.insert(PT+1, input())
return
def Renover():
global V_Arvore
# Adiciona o no raiz
if not V_Arvore:
print("Arvore vazia!")
return
print(V_Arvore)
print("Informe o elemento a ser removido: ", end='')
ELEM = input()
if V_Arvore.count(ELEM) == 0:
print("Elemento informado não está presente!")
return
# Obtem a posicao do PAI
P=V_Arvore.index(ELEM)
# Verifica se é uma folha o no informado
if V_Arvore[P+1] == "#" or V_Arvore[P+1] == "|":
del V_Arvore[P]
print("Elemento Removido!")
if V_Arvore[P] == "|" and V_Arvore[P-1] == "|":
del V_Arvore[P-1]
del V_Arvore[P-1]
return
if V_Arvore[P-1] == "#" or V_Arvore[P-1] == "|":
del V_Arvore[P-1]
PS = V_Arvore.index("#", P-1)
for i in reversed(range(PS)):
if V_Arvore[i] == "#":
PI = i
break
if not PI:
return
c = 0
for i in range(PI, PS):
if V_Arvore[i] == "|" :
c += 1
if c == 1:
for i in range(PI, PS):
if V_Arvore[i] == "|" :
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

28. 27/07/2022 15:53
Arvore_Contiguidade.py
Página 3 de 4
http://localhost:4649/?mode=python
if V_Arvore[i] == "|" :
del V_Arvore[i]
return
# Não pode remover o nó
print("Elemento nao pode ser removido pois não é uma folha!")
return
def Buscar():
# Informa a arvore Vazia
if not V_Arvore:
print("Arvore vazia!")
return
# Verifica se o Elemento esta presente
print("Informe o elemento a ser buscado: ", end='')
ELEM = input()
if ELEM not in V_Arvore:
print("Elemento informado não está presente!")
return
v_temp = []
Ramo = False
# Determina o Caminho
for i in reversed(range(V_Arvore.index(ELEM)+1)):
if V_Arvore[i] == "#":
Ramo = True
continue
if V_Arvore[i] == "|":
t = i
while not Ramo:
if V_Arvore[t] == "#":
Ramo = True
v_temp.append(V_Arvore[t+1])
t = t - 1
continue
if not Ramo or i == 0:
v_temp.append(V_Arvore[i])
# Imprime o Caminho partindo da raiz
v_temp.reverse()
print(*v_temp, sep=" --> ")
def Imprimir():
# Informa a arvore Vazia
if not V_Arvore:
print("Arvore vazia!")
return
print(V_Arvore)
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

29. 27/07/2022 15:53
Arvore_Contiguidade.py
Página 4 de 4
http://localhost:4649/?mode=python
print(V_Arvore)
return
# Opcoes
ans=True
while ans:
print("""
1.Adicionar
2.Delete
3.Buscar
4.Imprimir
5.Exit/Quit
""")
ans=input("Qual a opção? ")
if ans=="1": # Add
Inserir()
elif ans=="2": # Remove
Renover()
elif ans=="3": # busca
Buscar()
elif ans=="4": # busca
Imprimir()
elif ans=="5": # Imprimir
print("n Goodbye!!!")
ans = None
else:
print("n Opção inválida")
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

30. 27/07/2022 15:53
encadeada.py
Página 1 de 3
http://localhost:4649/?mode=python
# Arvore Encadeada
class Node:
"""
Class Node
"""
def __init__(self, value):
self.left = None
self.data = value
self.right = None
class Tree:
"""
Class tree will provide a tree as well as utility functions.
"""
def createNode(self, data):
"""
Utility function to create a node.
"""
return Node(data)
def insert(self, node , data):
"""
Insert function will insert a node into tree.
Duplicate keys are not allowed.
"""
#if tree is empty , return a root node
if node is None:
return self.createNode(data)
# if data is smaller than parent , insert it into left side
if data < node.data:
node.left = self.insert(node.left, data)
elif data > node.data:
node.right = self.insert(node.right, data)
return node
def search(self, node, data):
"""
Search function will search a node into tree.
"""
# if root is None or root is the search data.
if node is None or node.data == data:
return node
if node.data < data:
return self.search(node.right, data)
else:
return self.search(node.left, data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

31. 27/07/2022 15:53
encadeada.py
Página 2 de 3
http://localhost:4649/?mode=python
def deleteNode(self,node,data):
"""
Delete function will delete a node into tree.
Not complete , may need some more scenarion that we can handle
Now it is handling only leaf.
"""
# Check if tree is empty.
if node is None:
return None
# searching key into BST.
if data < node.data:
node.left = self.deleteNode(node.left, data)
elif data > node.data:
node.right = self.deleteNode(node.right, data)
else: # reach to the node that need to delete from BST.
if node.left is None and node.right is None:
del node
if node.left == None:
temp = node.right
del node
return temp
elif node.right == None:
temp = node.left
del node
return temp
return node
def traverseInorder(self, root):
"""
traverse function will print all the node in the tree.
"""
if root is not None:
self.traverseInorder(root.left)
print(root.data)
self.traverseInorder(root.right)
def traversePreorder(self, root):
"""
traverse function will print all the node in the tree.
"""
if root is not None:
print(root.data)
self.traversePreorder(root.left)
self.traversePreorder(root.right)
def traversePostorder(self, root):
"""
traverse function will print all the node in the tree.
"""
if root is not None:
self.traversePostorder(root.left)
self.traversePostorder(root.right)
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

32. 27/07/2022 15:53
encadeada.py
Página 3 de 3
http://localhost:4649/?mode=python
self.traversePostorder(root.right)
print(root.data)
def main():
root = None
tree = Tree()
root = tree.insert(root, 10)
print(root)
tree.insert(root, 20)
tree.insert(root, 30)
tree.insert(root, 40)
tree.insert(root, 70)
tree.insert(root, 60)
tree.insert(root, 80)
print("Traverse Inorder")
tree.traverseInorder(root)
print("Traverse Preorder")
tree.traversePreorder(root)
print("Traverse Postorder")
tree.traversePostorder(root)
if __name__ == "__main__":
main()
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137