Tutorial básico de Python: explicación detallada del recorrido del árbol de implementación de Python primero en profundidad y primero en amplitud

@Este artículo proviene del número público: csdn2299, como si pudieras prestar atención a la academia de programadores de números públicos.
Este artículo describe el recorrido transversal primero y el primero del árbol de implementación de Python. Comparta con usted para su referencia, de la siguiente manera:

Ancho primero (nivel transversal)

Comenzando desde la raíz del árbol, atravesando todo el árbol de arriba a abajo y de izquierda a derecha

La diferencia entre el número de nodos y el árbol binario es que el árbol binario tiene solo dos nodos a la izquierda y a la derecha

Prioridad de amplitud: A-B-C-D-E-F-G-H-I

Implementación 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)

Profundidad primero

Hay tres tipos de algoritmos de profundidad primero: recorrido de preorden, recorrido de orden medio y recorrido de
postorden. Nodo raíz-> subárbol izquierdo-> subárbol derecho

#实现 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)

Recorrido en orden En el recorrido en orden, utilizamos recursivamente el recorrido en orden para acceder al subárbol izquierdo, luego accedemos al nodo raíz y finalmente utilizamos recursivamente el recorrido en orden para acceder al subárbol derecho

Subárbol izquierdo-> nodo raíz-> subárbol derecho

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

Recorrido de orden posterior En el recorrido de orden posterior, primero usamos el recorrido recursivo para acceder a los subárboles izquierdo y derecho, y finalmente acceder al nodo raíz

Subárbol izquierdo-> subárbol derecho-> nodo raíz

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

Muchas gracias por leer
. Cuando decidí estudiar Python en la universidad, descubrí que me comía una mala base informática. No tenía una calificación académica. Esto
no es nada que hacer. Solo puedo compensarlo, así que comencé mi propio contraataque fuera de la codificación. El camino, continúe aprendiendo los conocimientos básicos de Python, el estudio en profundidad de los conceptos básicos de la computadora, resuelto, si no está dispuesto a ser mediocre, ¡únase a mí en la codificación y continúe creciendo!
De hecho, no solo hay tecnología aquí, sino también cosas más allá de esas tecnologías. Por ejemplo, cómo ser un programador exquisito, en lugar de "seda de gallo", el programador en sí es una existencia noble, ¿no? [Haz clic para unirte] ¡ Quieres ser tú mismo, quieres ser una persona noble, vamos!