Aula 17 - Algoritmos e Estruturas de Dados - A-Rvores Bina-Rias de Busca - V1

Aula 17 – Árvore Binária de Busca
• Árvore binária especial
• Útil na realização de pesquisas
Algoritmos e Estruturas de Dados 1

• Definição recursiva
• Árvore binária que pode estar vazia ou possuir as seguintes propriedades
• Todos os valores na sub árvore esquerda da raiz são menores que o valor na
raiz
• Todos os valores na sub árvore direita da raiz são maiores que o valor na raiz
• As sub árvores esquerda e direita da raiz são também árvores binárias de

busca

70
40 80
35 50 75 89
30 37 55 82 93

70
40 80
35 50 77 90
37 82
38 81 84

70
40 80
35 89
30 93

50
40
35
33
12

40
45
55
83
92

40
20
30
25
27

• Percurso em Árvore Binária de Busca
• Mesma forma que na Árvore Binária
70
40 80
35 50 75 89
30 37 55 82 93
Pré Ordem: 70 40 35 30 37 50 55 80 75 89 82 93

70
40 80
35 50 75 89
30 37 55 82 93
Em Ordem: 30 35 37 40 50 55 70 75 80 82 89 93

70
40 80
35 50 75 89
30 37 55 82 93
Pós Ordem: 30 37 35 55 50 40 75 82 93 89 80 70

70
40 80
35 50 75 89
30 37 55 82 93
Ordem Por Nível: 70 40 80 35 50 75 89 30 37 55 82 93

Pré Ordem: 70 40 35 30 37 50 55 80 75 89 82 93
Em Ordem: 30 35 37 40 50 55 70 75 80 82 89 93 Ordem Crescente
Pós Ordem: 30 37 35 55 50 40 75 82 93 89 80 70
Ordem Por Nível: 70 40 80 35 50 75 89 30 37 55 82 93

• Realizando a Busca em uma Árvore Binária de Busca
• info é o valor que será buscado
• Inicia no nó raiz e percorre abaixo a árvore

• Se info for igual ao valor da informação no nó atual
• A busca ocorreu com sucesso
• Se info for menor que o valor da informação do nó atual
• Vai para o nó esquerdo
• Se info for maior que o valor da informação do nó atual
• Vai para o nó direito

• info é o valor que será buscado
• Se for alcançado um nó esquerdo nulo ou um nó direito nulo
• A busca fracassou
• info não esta presente na árvore

70
40 80
35 50 75 89
30 37 55 82 93
Buscar 37

70
40 80
35 50 75 89
30 37 55 82 93
Buscar 77

• Busca mais eficiente que na Lista Ligada
• Complexidade de tempo de execução é , onde é a altura da árvore

Aula 16 – Árvore Binária de Busca (Python)
• Implementação da Busca em def BuscarIterativo(self, info):
p = raiz
Árvore Binária de Busca while (p is not None):
if (info < p.info):
# move para o filho esquerdo
p = p.noEsquerdo
else if (info > p.info):
# move para o filho direito
p = p.noDireito
else:
# valor localizado
return true
return false

• Implementação da Busca em def Buscar(self, info):
return (BuscarRecursivo(raiz, info)
Árvore Binária de Busca is not None)
def BuscarRecursivo(self, no, info):

if (no is None):
return None # valor nao localizado

if (info < no.info):
# pesquisa na sub arvore da esquerda
return BuscarRecursivo(no.noEsquerdo, info)

if (info > no.info):
# pesquisa na sub arvore da direita
return BuscarRecursivo(no.noDireito, info)

return no # valor encontrado

• Implementação da Busca em Árvore Binária de Busca 54
arvore.Buscar(45)
Verdadeiro 42 69
Buscar(info) {
retorna (BuscarRecursivo(raiz, info) != Nulo)
} BuscarRecursivo(no, info) { 48 55
se (no == Nulo) retorna Nulo 45
se (info < no.info)
BuscarRecursivo(no, info) { retorna BuscarRecursivo(no.noEsq, info)
se (no == Nulo) retorna Nulo 54 se (info > no.info) 45
se (info < no.info) retorna BuscarRecursivo(no.noDir, info)
retorna BuscarRecursivo(no.noEsq, info) retorna no
se (info > no.info) }
retorna BuscarRecursivo(no.noDir, info)
retorna no
}
BuscarRecursivo(no, info) { BuscarRecursivo(no, info) {

se (no == Nulo) retorna Nulo 42 se (no == Nulo) retorna Nulo 48
se (info < no.info) se (info < no.info)
retorna BuscarRecursivo(no.noEsq, info) retorna BuscarRecursivo(no.noEsq, info)
se (info > no.info) se (info > no.info)
retorna BuscarRecursivo(no.noDir, info) retorna BuscarRecursivo(no.noDir, info)
retorna no retorna no
} }
Buscar 45

• Implementação da Busca em Árvore Binária de Busca 54
arvore.Buscar(58)
Falso 42 69
Buscar(info) {
retorna (BuscarRecursivo(raiz, info) != Nulo)
} BuscarRecursivo(no, info) { 48 55
se (no == Nulo) retorna Nulo
se (info < no.info)
BuscarRecursivo(no, info) { retorna BuscarRecursivo(no.noEsq, info)
se (no == Nulo) retorna Nulo 54 se (info > no.info) 45
se (info < no.info) retorna BuscarRecursivo(no.noDir, info)
retorna BuscarRecursivo(no.noEsq, info) retorna no
se (info > no.info) }
retorna BuscarRecursivo(no.noDir, info)
retorna no
}
BuscarRecursivo(no, info) { BuscarRecursivo(no, info) {

se (no == Nulo) retorna Nulo 69 se (no == Nulo) retorna Nulo 55
se (info < no.info) se (info < no.info)
retorna BuscarRecursivo(no.noEsq, info) retorna BuscarRecursivo(no.noEsq, info)
se (info > no.info) se (info > no.info)
retorna BuscarRecursivo(no.noDir, info) retorna BuscarRecursivo(no.noDir, info)
retorna no retorna no
} }
Buscar 58

• Nós com valor Máximo e Mínimo
• Nó com o menor valor
• Último nó no caminho mais a esquerda iniciando na raiz
• Nó com o maior valor
• Último nó no caminho mais a direita iniciando na raiz

70
40 80
35 50 75 89
30 37 55 82 93

70
40 80
35 50 77 90
37 82
38 81 84

50
40
35
33
12

40
45
55
83
92

40
20
30
25
27

• Implementação do Obter Valores def ObterValorMinimo(self):
if (VerificarSeVazia()):
Máximo e Mínimo print("arvore esta vazia")
return
return ObterValorMinimoRecursivo(raiz).info
def ObterValorMinimoRecursivo(self, p):

if (p.noEsquerdo is None):
return p
return ObterValorMinimoRecursivo(p.noEsquerdo)

def ObterValorMinimoIterativo(self):
print("arvore esta vazia")
return

p = raiz
while (p.noEsquerdo is not None):
p = p.noEsquerdo

return p.info

• Implementação do Obter Valores def ObterValorMaximo(self):
Máximo e Mínimo print("arvore esta vazia")
return
return ObterValorMaximoRecursivo(raiz).info
def ObterValorMaximoRecursivo(self, p):

if (p.noDireito is None)
return p

return ObterValorMaximoRecursivo(p.noDireito)
def ObterValorMaximoIterativo(self):
print("arvore esta vazia")
return

p = raiz
while (p.noDireito is not None):
p = p.noDireito

return p.info

• Inserir na Árvore Binária de Busca
• Inserir um novo nó com valor info
• Inicia no nó raiz e se desloca abaixo na árvore binária
• Se info for menor que o valor no nó atual – Vai para o filho a esquerda
• Se info for maior que o valor no nó atual – Vai para o filho a direita
• Se info for igual ao valor no nó atual – Valor duplicado
• Se alcançar um filho esquerdo nulo ou um filho direito nulo
• Realiza a inserção

70
40 80
35 50 75 89
30 37 55 82 93
36
Inserir 36

70
40 80
35 50 75 89
30 37 55 77 82 93
36
Inserir 77

• Construir a Árvore Binária de Busca
45
39 60
23 42 55 79
10 34 44 57 77 83
29
45 60 55 39 23 79 57 42 10 34 83 29 77 44

• Implementação do Inserir na def InserirIterativo(self, info)
p = raiz
Árvore Binária de Busca pai = None
while (p is not None)

pai = p
if (info < p.info):

p = p.noEsquerdo
else if (info > p.info):
p = p.noDireito
else:
print(info +
" ja existe na arvore")
return
no = No(info)
if (pai is None):
raiz = no
else if (info < pai.info):
pai.noEsquerdo = no
else:
pai.noDireito = no

• Inserção Iterativa pai nulo
pai p 70
pai
p 40 80
p 35 pai 50 75 89
30 p 37 55 82 93
temp 36 p nulo
pai.noEsq = temp
Inserir 36

• Implementação do Inserir na def Inserir(self, info):
raiz = InserirRecursivo(raiz, info)
Árvore Binária de Busca
def InserirRecursivo(self, no, info):
if (no is None):
no = No(info)
else if (info < no.info):
no.noEsquerdo = InserirRecursivo(
no.noEsquerdo, info)
else if (info > no.info):
no.noDireito = InserirRecursivo(
no.noDireito, info)
else:
print(info + " ja existe na arvore");
return no

• Inserção Recursiva InserirRecursivo(no, info) {
42
54
se (p == nulo) p = No(info)
senao se (info < p.info)
arvore.Inserir(50) p.noEsq = InserirRecursivo(p.noEsq, info)
senao se (info > no.info)
p.noDir = InserirRecursivo(p.noDir, info) 42 69
Inserir(info) { senao
raiz = InserirRecursivo(raiz, info) valor duplicado
} retorna p
}
48 55
InserirRecursivo(no, info) {
54
p.noEsq = InserirRecursivo(p.noEsq, info) 48
p.noDir = InserirRecursivo(p.noDir, info)
senao se (info < p.info) 45
p.noEsq = InserirRecursivo(p.noEsq, info)
senao
valor duplicado
retorna p
senao
}
valor duplicado
retorna p
}
senao
valor duplicado
retorna p
}
Inserir 50

• Inserção Recursiva Árvore Vazia
raiz nulo
arvore.Inserir(60)
Inserir(info) { InserirRecursivo(no, info) {
raiz = InserirRecursivo(raiz, info) se (p == nulo) p = No(info)
} senao se (info < p.info)
senao
valor duplicado
retorna p
}
Inserir 60 (* colocar setas indo em vermelho acompanhando a func em vermelho e setas voltando em preto)

• Remover da Árvore Binária de Busca
• Primeiro encontrar o nó que será removido
• Três possibilidades
• Caso A – O nó não possui filhos, é um nó folha
• Caso B - O nó possui apenas um nó filho
• Caso C - O nó possui dois nós filhos

• Para remoção de um nó folha
• A referencia do pai para o nó folha para a apontar para nulo
• Se o nó a ser removido for o filho esquerdo
• O filho esquerdo do nó pai se torna nulo
• Se o nó a ser removido for o filho direito
• O filho direito do nó pai se torna nulo


pai.noDireita = nulo
45
39 60
pai 23 42 55 79
p 34 83
Remover 34


pai.noEsquerda = nulo
45
39 pai 60
23 42 55 79
83
p
Remover 55


pai == nulo
raiz = nulo raiz 45 pai nulo
Remover 45

• Caso B – O nó possui apenas um filho
• p é o nó que será removido
• pai é uma referência ao nó pai de p
• filho é uma referência ao nó filho de p
• Se p está a esquerda de pai  filho se torna o filho esquerdo de pai
• Se p está a direita de pai  filho se torna o filho direito de pai


pai.noDireita = filho
45
39 60
pai 23 42 79
10 34 44 44 83
filho 29
Remover 34 p


pai.noEsquerda = filho
pai 45
p 39 60
filho 23 79
10 29 44 83
Remover 39


raiz = filho
raiz 45 pai nulo
p
raiz 60 filho
50 79
77 83
Remover 45

• Caso C – O nó possui dois filhos
• Encontrar o sucessor do nó que será removido usando percurso Em Ordem
• Sucessor Em Ordem de um Nó
• Nó mais a esquerda da sub árvore direta do nó que será removido

70
30 84
12 45 78 95
9 38 60 72 86
35 73

• Encontra o sucessor Em Ordem do nó que será removido
• Copia a informação do sucessor Em Ordem para o nó que será removido
• Remove o sucessor Em Ordem da árvore
• Caso A
• Caso B


CASO A pai 45
nulo
39 69
60
23 42 55 79
p
10 34 44 57 ps 77 83
29 sucessor 69 p
Remover 60


CASO B pai 52
nulo
42
40 p 69
60
23 48 55 79
10 45 ps 50 57 77 83
sucessor 42 p
43
Remover 40


CASO A pai nulo p
52
54
42
40 69
p
23 48 55 ps 79
10 45 50 54 57 77 83
43
sucessor
Remover 52

• Implementação do Remover na
def remover(self, info):
self.raiz = self.removerRecursivo(self.raiz, info)
Árvore Binária de Busca def removerRecursivo(self, no, info):

if (no == None):
print(str(info) + ' nao localizado')
return no

if (info < no.info):
# remove da sub arvore esquerda
no.noEsquerdo = self.removerRecursivo(no.noEsquerdo, info)
elif (info > no.info):
# remove da sub arvore direita
no.noDireito = self.removerRecursivo(no.noDireito, info)
else:
# valor que sera removido foi localizado
# dois filhos
if (no.noEsquerdo != None and no.noDireito != None):
s = no.noDireito
while (s.noEsquerdo != NOne):
s = s.noEsquerdo
no.info = s.info
no.noDireito = self.removerRecursivo(no.noDireito, s.info)
else: # um filho ou nenhum filho
# apenas o filho esquerdo
if (no.noEsquerdo != None):
filho = no.noEsquerdo
else:
# apenas o filho direito ou nenhum filho
filho = no.noDireito
no = filho
return no

def removerIterativo(self, info):
p = self.raiz
pai = None
Árvore Binária de Busca while (p != None):
if (info == p.info):
break
pai = p
if (info < p.info):

p = p.noEsquerdo
else:
p = p.noDireito

if (p == None):
print(str(info) + ' nao encontrado');
return
# caso c - dois filhos

# encontra o sucessor em ordem e seu pai
if ((p.noEsquerdo != None) and (p.noDireito != None)):
ps = p
s = p.noDireito
while (s.noEsquerdo != None):

ps = s
s = s.noEsquerdo
p.info = s.info
p = s
pai = os

# caso b e caso a - um ou nenhum filho
# no que sera removido possui filho a esquerda
if (p.noEsquerdo != None):
Árvore Binária de Busca filho = p.noEsquerdo
# no que sera removido possui filho a direita ou nenhum filho
else:
filho = p.noDireito

# no que sera removido eh o no raiz
if (pai == None):
self.raiz = filho
# no eh o filho esquedo de pai
elif (p == pai.noEsquerdo):
pai.noEsquerdo = filho
# no eh o filho direito de pai
else:
pai.noDireito = filho

• Implementação de Árvore Binária de Busca
1 from no import No 29 def buscar(self, info):
2 from queue import Queue 30 return (self.buscarRecursivo(self.raiz, info)
3 is not None)
4 class ArvoreBinariaBusca(object): 31
5 def __init__(self): 32 def buscarRecursivo(self, no, info):
6 self.raiz = None 33 if (no is None):
7 34 return None # valor nao localizado
8 def verificarSeVazia(self): 35
9 return (self.raiz is None) 36 # pesquisa na sub arvore da esquerda
10 37 if (info < no.info):
11 def exibir(self): 38 return self.buscarRecursivo(no.noEsquerdo, info)
12 self.exibirRecursivo(self.raiz, 0) 39
13 print() 40 # pesquisa na sub arvore da direita
14 41 if (info > no.info):
15 def exibirRecursivo(self, p, nivel): 42 return self.buscarRecursivo(no.noDireito, info)
16 if (p == None): 43
17 return 44 return no # valor encontrado
18
19 self.exibirRecursivo(p.noDireito, nivel + 1)
20 print()
21
22 for i in range(nivel):
23 print(' ', end='')
24
25 print(p.info)
26
27 self.exibirRecursivo(p.noEsquerdo, nivel + 1)

46 def buscarIterativo(self, info): 62 def inserir(self, info):
47 p = self.raiz 63 self.raiz = self.inserirRecursivo(self.raiz, info)
48 64
49 while (p is not None): 65 def inserirRecursivo(self, no, info):
50 if (info < p.info): 66 if (no is None):
51 # move para o filho esquerdo 67 no = No(info)
52 p = p.noEsquerdo 68 elif (info < no.info):
53 elif (info > p.info): 69 no.noEsquerdo = self.inserirRecursivo(
54 # move para o filho direito no.noEsquerdo, info)
55 p = p.noDireito 70 elif (info > no.info):
56 else: 71 no.noDireito = self.inserirRecursivo(
57 # valor localizado no.noDireito, info)
58 return True 72 else:
59 73 print(str(info) + " ja existe na arvore");
60 return False 74
75 return no

77 def inserirIterativo(self, info): 101 def remover(self, info):
78 p = self.raiz 102 self.raiz = self.removerRecursivo(self.raiz, info)
79 pai = None 103
80 104 def removerRecursivo(self, no, info):
81 while (p is not None): 105 if (no == None):
82 pai = p 106 print(str(info) + ' nao localizado')
83 107
84 if (info < p.info): 108 return no
85 p = p.noEsquerdo 109
86 elif (info > p.info): 110 if (info < no.info):
87 p = p.noDireito 111 # remove da sub arvore esquerda
88 else: 112 no.noEsquerdo = self.removerRecursivo(no.noEsquerdo
89 print(str(info) + ' ja existe na arvore') , info)
90 return 113 elif (info > no.info):
91 114 # remove da sub arvore direita
92 no = No(info) 115 no.noDireito = self.removerRecursivo(no.noDireito,
93 info)
94 if (pai is None): 116 else:
95 self.raiz = no 117 # valor que sera removido foi localizado
96 elif (info < pai.info): 118 # dois filhos
97 pai.noEsquerdo = no 119 if (no.noEsquerdo != None and no.noDireito !
98 else: = None):
99 pai.noDireito = no 120 s = no.noDireito
121
122 while (s.noEsquerdo != NOne):
123 s = s.noEsquerdo
124
125 no.info = s.info

126 no.noDireito = self.removerRecursivo( 139 def removerIterativo(self, info):
no.noDireito, s.info) 140 p = self.raiz
127 else: # um filho ou nenhum filho 141 pai = None
128 # apenas o filho esquerdo 143 while (p != None):
129 if (no.noEsquerdo != None): 144 if (info == p.info):
130 filho = no.noEsquerdo 145 break
131 else: 147 pai = p
132 # apenas o filho direito ou nenhum filho 148
133 filho = no.noDireito 149 if (info < p.info):
134 150 p = p.noEsquerdo
135 no = filho 151 else:
136 152 p = p.noDireito
137 return no 153
154 if (p == None):
155 print(str(info) + ' nao encontrado');
156 return
157
158 # caso c - dois filhos
159 # encontra o sucessor em ordem e seu pai
160 if ((p.noEsquerdo != None) and (p.noDireito != None)):
161 ps = p
162 s = p.noDireito
163
164 while (s.noEsquerdo != None):
165 ps = s
166 s = s.noEsquerdo
168 p.info = s.info
169 p = s
170 pai = ps

172 # caso b e caso a - um ou nenhum filho 204 # em ordem
173 # no que sera removido possui filho a esquerda 205 def percorrerEmOrdem(self):
174 if (p.noEsquerdo != None): 206 self.percorrerEmOrdemRecursivo(self.raiz)
175 filho = p.noEsquerdo 207 print()
176 # no que sera removido possui filho 208
a direita ou nenhum filho 209 # em ordem
177 else: 210 def percorrerEmOrdemRecursivo(self, p):
178 filho = p.noDireito 211 if (p == None):
179 212 return
180 # no que sera removido eh o no raiz 213
181 if (pai == None): 214 self.percorrerEmOrdemRecursivo(p.noEsquerdo)
182 self.raiz = filho 215 print(str(p.info) + ' ')
183 # no eh o filho esquedo de pai 216 self.percorrerEmOrdemRecursivo(p.noDireito)
184 elif (p == pai.noEsquerdo): 217
185 pai.noEsquerdo = filho 218 # pos ordem
186 # no eh o filho direito de pai 219 def percorrerPosOrdem(self):
187 else: 220 self.percorrerPosOrdemRecursivo(self.raiz)
188 pai.noDireito = filho 221 print()
190 # pre ordem 222
191 def percorrerPreOrdem(self): 223 # pos ordem
192 self.percorrerPreOrdemRecursivo(self.raiz) 224 def percorrerPosOrdemRecursivo(self, p):
193 print() 225 if (p == None):
195 # pre ordem 226 return
196 def percorrerPreOrdemRecursivo(self, p): 227
197 if (p == None): 228 self.percorrerPosOrdemRecursivo(p.noEsquerdo)
198 return 229 self.percorrerPosOrdemRecursivo(p.noDireito)
200 print(str(p.info) + ' ') 230 print(str(p.info) + ' ’)
201 self.percorrerPreOrdemRecursivo(p.noEsquerdo)
202 self.percorrerPreOrdemRecursivo(p.noDireito)

232 # por nivel 255 def obterAltura(self):
233 def percorrerPorNivel(self): 256 return self.obterAlturaRecursivo(self.raiz)
234 if (self.raiz == None): 257
235 print("Arvore Vazia") 258 def obterAlturaRecursivo(self, p):
236 259 if (p == None):
237 return 260 return 0
238 261
239 q = Queue() 262 alturaEsquerda = self.obterAlturaRecursivo(
240 q.put(self.raiz) p.noEsquerdo)
241 263 alturaDireita = self.obterAlturaRecursivo(p.noDireito)
242 while (q.qsize() != 0): 264
243 p = q.get() 265 if (alturaEsquerda > alturaDireita):
244 266 return alturaEsquerda + 1
245 print(str(p.info) + ' ') 267 else:
246 268 return alturaDireita + 1
247 if (p.noEsquerdo != None):
248 q.put(p.noEsquerdo)
249
250 if (p.noDireito != None):
251 q.put(p.noDireito)
252
253 print()

270 def obterValorMinimo(self): 295 def obterValorMaximo(self):
271 if (self.verificarSeVazia()): 296 if (self.verificarSeVazia()):
272 print("arvore esta vazia") 297 print("arvore esta vazia")
273 return 298 return
274 299
275 return self.obterValorMinimoRecursivo(self.raiz).info 300 return self.obterValorMaximoRecursivo(self.raiz).info
276 301
277 def obterValorMinimoRecursivo(self, p): 302 def obterValorMaximoRecursivo(self, p):
278 if (p.noEsquerdo is None): 303 if (p.noDireito is None):
279 return p 304 return p
280 305
281 return self.obterValorMinimoRecursivo(p.noEsquerdo) 306 return self.obterValorMaximoRecursivo(p.noDireito)
282 307
283 def obterValorMinimoIterativo(self): 308 def obterValorMaximoIterativo(self):
284 if (self.verificarSeVazia()): 309 if (self.verificarSeVazia()):
285 print("arvore esta vazia") 310 print("arvore esta vazia")
286 return 311 return
287 312
288 p = self.raiz 313 p = self.raiz
289 314
290 while (p.noEsquerdo is not None): 315 while (p.noDireito is not None):
291 p = p.noEsquerdo 316 p = p.noDireito
292 317
293 return p.info 318 return p.info

• Implementação de Árvore Binária de Busca (Demonstração)
1 from arvore_binaria_busca import ArvoreBinariaBusca 25 def buscarRecursivo():
2 26 info = int(input('entre o valor que sera procurado: '))
3 arvoreBinariaBusca = ArvoreBinariaBusca() 27
4 28 if (arvoreBinariaBusca.buscar(info)):
5 def escolherOpcao(escolha): 29 print("valor localizado")
6 opcoes = { 30 else:
7 1: arvoreBinariaBusca.exibir, 31 print("valor nao localizado")
8 2: buscarRecursivo, 32
9 3: buscarIterativo, 33 def buscarIterativo():
10 4: inserirRecursivo, 34 info = int(input('entre o valor que sera procurado: '))
11 5: inserirIterativo, 35
12 6: removerRecursivo, 36 if (arvoreBinariaBusca.buscarIterativo(info)):
13 7: removerIterativo, 37 print("valor localizado")
14 8: arvoreBinariaBusca.percorrerPreOrdem, 38 else:
15 9: arvoreBinariaBusca.percorrerEmOrdem, 39 print("valor nao localizado")
16 10: arvoreBinariaBusca.percorrerPosOrdem, 40
17 11: arvoreBinariaBusca.percorrerPorNivel, 41 def inserirRecursivo():
18 12: obterAltura, 42 info = int(input('entre o valor que sera inserido: '))
19 13: obterMenorValor, 43 arvoreBinariaBusca.inserir(info)
20 14: obterMaiorValor 44
21 } 45 def inserirIterativo():
22 46 info = int(input('entre o valor que sera inserido: '))
23 opcoes.get(escolha, ‘’)() 47 arvoreBinariaBusca.inserirIterativo(info)
48
49 def removerRecursivo():
50 info = int(input('entre o valor que sera removido: '))
51 arvoreBinariaBusca.remover(info)

• Implementação de Árvore Binária de Busca (Demonstração)
53 def removerIterativo(): 68 def main():
54 info = int(input('entre o valor que sera removido: ')) 69
55 arvoreBinariaBusca.removerIterativo(info) 70 while(True):
56 71 print('1. Exibir Arvore')
57 def obterAltura(): 72 print('2. Buscar Recursivo')
58 print('a altura da arvore eh ’ + 73 print('3. Buscar Iterativo')
str(arvoreBinariaBusca.obterAltura())) 74 print('4. Inserir um Novo No (Recursivo)')
59 75 print('5. Inserir um Novo No (Iterativo)')
60 def obterMenorValor(): 76 print('6. Remover um No (Recursivo)')
61 print('o menor valor na arvore eh ’ + 77 print('7. Remover um No (Iterativo)')
str(arvoreBinariaBusca.obterValorMinimo())) 78 print('8. Percorrer Pre Ordem')
62 #print('o menor valor na arvore eh ’ + 79 print('9. Percorrer Em Ordem')
str(arvoreBinariaBusca.obterValorMinimoIterativo())) 80 print('10. Percorrer Pos Ordem')
63 81 print('11. Percorrer Por Nivel')
64 def obterMaiorValor(): 82 print('12. Altura da Arvore')
65 print('o maior valor na arvore eh ’ + 83 print('13. Achar o Valor Minimo')
str(arvoreBinariaBusca.obterValorMaximo())) 84 print('14. Achar o Valor Maximo')
66 #print('o maior valor na arvore eh ’ + 85 print('15. Sair')
str(arvoreBinariaBusca.obterValorMaximoIterativo())) 86
87 escolha = int(input('escolha uma opcao: '))
88
89 if (escolha == 15):
90 break
91
92 escolherOpcao(escolha)
93
94 if __name__ == '__main__':
95 main()

Aula 17 - Algoritmos e Estruturas de Dados - A-Rvores Bina-Rias de Busca - V1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aula 17 - Algoritmos e Estruturas de Dados - A-Rvores Bina-Rias de Busca - V1

Enviado por

Direitos autorais:

Formatos disponíveis

Aula 17 – Árvore Binária de Busca

• Árvore binária especial

• Útil na realização de pesquisas

Algoritmos e Estruturas de Dados 1

• Árvore binária que pode estar vazia ou possuir as seguintes propriedades

• As sub árvores esquerda e direita da raiz são também árvores binárias de

Algoritmos e Estruturas de Dados 2

Algoritmos e Estruturas de Dados 3

Algoritmos e Estruturas de Dados 4

Algoritmos e Estruturas de Dados 5

Algoritmos e Estruturas de Dados 6

Algoritmos e Estruturas de Dados 7

Algoritmos e Estruturas de Dados 8

• Mesma forma que na Árvore Binária

Algoritmos e Estruturas de Dados 9

• Mesma forma que na Árvore Binária

Algoritmos e Estruturas de Dados 10

• Mesma forma que na Árvore Binária

Algoritmos e Estruturas de Dados 11

• Mesma forma que na Árvore Binária

Ordem Por Nível: 70 40 80 35 50 75 89 30 37 55 82 93

Algoritmos e Estruturas de Dados 12

• Mesma forma que na Árvore Binária

Em Ordem: 30 35 37 40 50 55 70 75 80 82 89 93 Ordem Crescente

Ordem Por Nível: 70 40 80 35 50 75 89 30 37 55 82 93

Algoritmos e Estruturas de Dados 13

• info é o valor que será buscado

• Inicia no nó raiz e percorre abaixo a árvore

• A busca ocorreu com sucesso

• Se info for menor que o valor da informação do nó atual

• Vai para o nó esquerdo

• Se info for maior que o valor da informação do nó atual

• Vai para o nó direito

Algoritmos e Estruturas de Dados 14

• info é o valor que será buscado

• Se for alcançado um nó esquerdo nulo ou um nó direito nulo

• info não esta presente na árvore

Algoritmos e Estruturas de Dados 15

Algoritmos e Estruturas de Dados 16

Algoritmos e Estruturas de Dados 17

• Busca mais eficiente que na Lista Ligada

• Complexidade de tempo de execução é , onde é a altura da árvore

Algoritmos e Estruturas de Dados 18

Algoritmos e Estruturas de Dados 19

def BuscarRecursivo(self, no, info):

Algoritmos e Estruturas de Dados 20

BuscarRecursivo(no, info) { BuscarRecursivo(no, info) {

Algoritmos e Estruturas de Dados 21

BuscarRecursivo(no, info) { BuscarRecursivo(no, info) {

Algoritmos e Estruturas de Dados 22

• Nó com o menor valor

• Último nó no caminho mais a esquerda iniciando na raiz

• Nó com o maior valor

• Último nó no caminho mais a direita iniciando na raiz

Algoritmos e Estruturas de Dados 23

Algoritmos e Estruturas de Dados 24

Algoritmos e Estruturas de Dados 25

Algoritmos e Estruturas de Dados 26

Algoritmos e Estruturas de Dados 27

Algoritmos e Estruturas de Dados 28

def ObterValorMinimoRecursivo(self, p):

Algoritmos e Estruturas de Dados 29

def ObterValorMaximoRecursivo(self, p):