Revisión transversal de profundidad (primer orden, orden medio, segundo orden)

. 1  clase Nodo (Object):
 2      '' ' define un nodo tiene un hijo izquierdo y un hijo derecho ' '' 
3.      DEF  la __init__ (Self, Data):
 . 4          # datos de nodo 
5.          Self.data = Data
 6.          # Izquierda y Derecha niño es punto nulo 
7.          self.lchild = Ninguno
 8.          self.rchild = Ninguno
 9.  
10  clase BinaryTree (Object):
 . 11      '' ' binario ' '' 
12 es      DEF  la __init__ (Self):
 13 es          # nodo raíz está vacío por defecto 
14          Ser. raíz = ninguna
15  
16      DEF Añadir (Ser, datos):
 . 17          # datos se suman para añadir datos a un árbol binario para finalmente 
18          # nodo padre dejó infantil y la derecha: procesamiento de pedidos 
. 19          Node = Nodo (datos)
 20 es          # Si árbol vacío 
21 es          SI Auto .root iS Ninguno:
 22 se              self.root = nodo
 23 es              # árbol vacío, los datos añadidos en el nodo raíz 
24              de retorno 
25          de la cola = [self.root]
 26 es          # adición de nodo raíz, como un signo de la presencia del nodo 
27          al mismo tiempo Queue :
 28              # Si la cola no está vacía 
29              cur_node =queue.pop (0)
 30              # actual punto de nodo raíz, toma el primer elemento 
31 se              IF cur_node.lchild ES Ninguno:
 32                  # Si se deja nodo vacío 
33 es                  cur_node.lchild = Nodo
 34 es                  de retorno 
35              el otro :
 36                  # add el puntero para probar la presencia de un nodo izquierdo 
37 [                  queue.append (cur_node.lchild)
 38 es              SI cur_node.rchild iS Ninguno:
 39                  # si el nodo derecho está vacía 
40                  cur_node.rchild = nodo
 41 es                  el retorno 
42 es              la otra cosa :
 43 es                 # Añadido al puntero, probar la existencia de la unión derecha 
44 es                  queue.append (cur_node.rchild)
 45  
46 es      DEF pre_order (Ser, Nodo):
 47          '' ' preorden -> acerca de la raíz ' '' 
48          SI Nodo ES Ninguno:
 49              de retorno 
50          de impresión (node.data, End = "  " )
 51 es          self.pre_order (nodo, lchild)
 52 es          # tiene un nodo recursiva izquierda, justo después de la travesía de retorno 
53 es          self.pre_order (nodo, rchild)
 54 está          # de desplazamiento derecha Hasta que esté vacío 
55  
56      def in_order (self, node):
 57          '' 'Preorden -> raíz izquierda y derecha '' ' 
58          SI Nodo ES Ninguno:
 59              de retorno 
60          self.in_order (Nodo, lchild)
 61 es          # tiene un nodo izquierda recursiva 
62 es          de impresión (node.data, End = "  " )
 63 es          # impresión los datos de salida 
64          self.in_order (nodo, rchild)
 65          # atraviesan los datos de la derecha 
66  
67  
68      DEF post_order (Ser, nodo):
 69          '' ' orden posterior -> acerca de la raíz ' '' 
70          SI nodo eS Ninguno:
 71 es              el retorno 
72         self.post_order (Node, lchild)
 73 es          # tiene una recursiva nodo izquierdo 
74          self.post_order (Node, rchild)
 75          # ha sido recursivamente derecho nodo 
76          de impresión (node.data, End = "  " )

2020-04-18

Supongo que te gusta

Origin www.cnblogs.com/hany-postq473111315/p/12725386.html
Recomendado
Clasificación