Você está aqui: Python ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca |
Como percorrer uma árvore binária em Python usando o algorítmo depth-first search (DFS) de forma iterativaQuantidade de visualizações: 384 vezes |
|
Nesta dica mostrarei como podemos implementar o algorítmo da Busca em Profundidade (DFS, do inglês depth-first search) em Python de forma iterativa, ou seja, sem usar recursividade. Não farei a busca, mas sim o percurso, para que você entenda como a lógica dessa busca funciona. Antes de iniciarmos, veja a árvore binária que vamos usar no exemplo: ![]() Note que esta árvore possui seis nós. O nó 5 é o nó raiz, e possui como filhos os nós 4 e 9. O nó 4, por sua vez, possui apenas um filho, o nó 2, ou seja, o filho da esquerda. O nó 9 possui dois filhos: o nó 3 é o filho da esquerda e o nó 12 é o filho da direita. Os filhos da árvore binária que não possuem outros filhos são chamados de folhas. Com a abordagem da busca em profundidade, começamos com o nó raiz e viajamos para baixo em uma única ramificação. Se o nó desejado for encontrado naquela ramificação, ótimo. Do contrário, continuamos subindo e pesquisando por nós não visitados. Esse tipo de busca também tem uma notação big O de O(n). Vamos à implementação? Veja o código para a classe No, que representa um nó na árvore binária: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# implementação da classe No
class No:
# construtor da classe
def __init__(self, valor):
# o valor do nó
self.valor = valor
# o filho da esquerda
self.esquerdo = None
# o filho da direita
self.direito = None
Veja agora o código completo para o exemplo. Note que usei uma implementação não-recursiva, na qual todos os nós expandidos recentemente são adicionados a uma pilha, para realizar a exploração. O uso da pilha permite o retrocesso (backtracking) de forma a reiniciarmos o percurso ou busca no próximo nó. Para manter o código o mais simples possível, eu usei a classe List do Python, juntamente com seus métodos append() e pop() para simular a pilha. Usei também uma List para guardar os valores da árvore binária na ordem depth-first. Eis o código: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# implementação da classe No
class No:
# construtor da classe
def __init__(self, valor):
# o valor do nó
self.valor = valor
# o filho da esquerda
self.esquerdo = None
# o filho da direita
self.direito = None
# função principal do programa Python
def main():
# vamos criar os nós da árvore
cinco = No(5) # será a raiz da árvore
quatro = No(4)
nove = No(9)
dois = No(2)
tres = No(3)
doze = No(12)
# vamos fazer a ligação entre os nós
cinco.esquerdo = quatro
cinco.direito = nove
quatro.esquerdo = dois
nove.esquerdo = tres
nove.direito = doze
# agora já podemos efetuar o percurso depth-first
valores = percurso_depth_first(cinco)
print("Os valores na ordem Depth-First são: {0}".format(valores))
# função que permite realizar a pesquisa depth-first search (DFS)
def percurso_depth_first(no):
# vamos usar uma List para retornar os elementos
# na ordem Depth-First
valores = list()
# vamos criar uma nova instância de uma list para representar uma pilha
pilha = list()
# já vamos adicionar o primeiro nó recebido, que é a raiz
pilha.append(no)
# enquanto a pilha não estiver vazia
while len(pilha) > 0:
# vamos obter o elemento no topo da pilha
atual = pilha.pop()
# adicionamos este valor na List
valores.append(atual.valor)
# vamos colocar o filho direito na pilha
if atual.direito != None:
pilha.append(atual.direito)
# vamos colocar o filho esquerdo na pilha
if atual.esquerdo != None:
pilha.append(atual.esquerdo)
return valores # retorna os valores da árvore
if __name__== "__main__":
main()
Ao executarmos este código Python nós teremos o seguinte resultado: Os valores na ordem Depth-First são: [5, 4, 2, 9, 3, 12] Compare estes valores com a imagem vista anteriormente para entender ainda melhor o percurso ou busca Depth-First. |
|
|
Desafios, Exercícios e Algoritmos Resolvidos de Python |
Veja mais Dicas e truques de Python |
Dicas e truques de outras linguagens |
|
AutoLISP - Como desenhar uma linha no AutoCAD usando AutoLISP - Dois pontos geométricos e o comando LINE |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |







