Tutorial básico do Python: árvore de implementação do Python - explicação detalhada da profundidade da primeira travessia e da largura da primeira travessia

@Este artigo é proveniente do número público: csdn2299, como você pode prestar atenção à academia de programadores de números públicos
Este artigo descreve a travessia profunda e a primeira travessia da árvore de implementação do Python. Compartilhe com você para sua referência, da seguinte maneira:

Largura primeiro (passagem de nível)

Começando pela raiz da árvore, percorrendo toda a árvore de cima para baixo e da esquerda para a direita

A diferença entre o número de nós e a árvore binária é que a árvore binária possui apenas dois nós à esquerda e à direita

Prioridade em largura: A-B-C-D-E-F-G-H-I

Implementação de código

def breadth_travel(self, root):
    """利用队列实现树的层次遍历"""
    if root == None:
      return
    queue = []
    queue.append(root)
    while queue:
      node = queue.pop(0)
      print node.elem,
      if node.lchild != None:
        queue.append(node.lchild)
      if node.rchild != None:
        queue.append(node.rchild)

Profundidade primeiro

Existem três tipos de algoritmos de profundidade primeiro: travessia de pré-ordem, travessia de ordem média e travessia de pós-
ordem.Nó raiz-> subárvore esquerda-> subárvore direita

#实现 1
def preorder(self, root):
   """递归实现先序遍历"""
   if root == None:
     return
   print root.elem
   self.preorder(root.lchild)
   self.preorder(root.rchild)

#实现 2
def depth_tree(tree_node):
  if tree_node is not None:
    print (tree_node._data)
    if tree_node._left is noe None:
      return depth_tree(tree_node._left)
    if tree_node._right is not None:
      return depth_tree(tree_node._right)

Percurso em ordem No percurso em ordem, usamos recursivamente o percurso em ordem para acessar a subárvore esquerda, depois o nó raiz e, finalmente, recursivamente usamos o percurso em ordem para acessar a subárvore direita

Subárvore esquerda-> nó raiz-> subárvore direita

def inorder(self, root):
   """递归实现中序遍历"""
   if root == None:
     return
   self.inorder(root.lchild)
   print root.elem
   self.inorder(root.rchild)

Percurso de pós-ordem No percurso de pós-ordem, primeiro usamos o percurso recursivo para acessar as subárvores esquerda e direita e, finalmente, acessar o nó raiz

Subárvore esquerda-> subárvore direita-> nó raiz

def postorder(self, root):
   """递归实现后续遍历"""
   if root == None:
     return
   self.postorder(root.lchild)
   self.postorder(root.rchild)
   print root.elem

Muito obrigado pela leitura
. Quando escolhi python na universidade, descobri que comia uma base ruim de computador. Não tinha qualificação acadêmica. Isso
não é o que fazer. Só posso compensar isso. Na estrada, continue a aprender o conhecimento básico de python, estudo aprofundado dos conceitos básicos de computador, resolvido, se você não estiver disposto a ser medíocre, junte-se a mim na codificação e continue a crescer!
De fato, não há apenas tecnologia aqui, mas também coisas além dessas tecnologias.Por exemplo, como ser um programador requintado, em vez de "seda artificial", o próprio programador é uma existência nobre, não é? [Clique para participar] Quer ser você mesmo, quer ser uma pessoa nobre, vamos lá!