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