RECORRIDO DE ORDEN DE NIVEL INVERSO DE UN ÁRBOL BINARIO
Operación que consiste en visitar todos sus vértices o nodos, de tal manera que cada vértice se visite una sola vez.
******************************************************************************************************
*************
from collections import deque Admite agregar y eliminar elementos de cualquier extremo de la cola.
# Una clase para almacenar un nodo de árbol binario
class Node: clase nodo:
def __init__(self, key=None, left=None, right=None): constr __init__, con los parametros…..
[Link] = key clave = clave
[Link] = left izquierda = izquierda
[Link] = right derecha = derecha
# Función para imprimir el recorrido de orden de nivel inverso de un árbol binario dado
def reverseLevelOrderTraversal(root): inverso nivel orden recorrido (raiz)
if root is None: si la raiz es Ninguno:
return devuelve
# crear una queue “cola” vacía y poner en queue el nodo raíz
queue = deque() cola = al que agregaremos con el deque()
[Link](root) cola.añada(raiz)
# crea una stack para invertir los nodos de orden de nivel
stack = deque() pila = al que agregaremos()
# Bucle # hasta que la queue esté vacía
while queue: mientras que la cola:
# procesa cada nodo en la queue y pone en queue a sus hijos
curr = [Link]() [Link] un elemento de lado izquierdo de la cola y devolverá el siguiente valor.
# empuja el nodo actual a la stack
[Link]([Link]) [Link]([Link])
# es importante procesar el nodo derecho antes que el nodo izquierdo
if [Link]: si [Link]:
[Link]([Link]) [Link]([Link])
if [Link]: si [Link]:
[Link]([Link]) [Link]([Link])
# saca todos los nodos de la stack e imprímelos
while stack: mientras se apila:
print([Link](), end=' ') imprimir([Link] el element superior(), el final=” ” )
if __name__ == '__main__': si, usamos un bloque __variable__ == “__establecemos__”: y usamos el modulo
root = Node(15) raiz = Nodo(15)
[Link] = Node(10) [Link] = Nodo(10)
[Link] = Node(20) [Link] = Nodo(20)
[Link] = Node(8) [Link] = Nodo(8)
[Link] = Node(12) [Link](12)
[Link] = Node(16) [Link](16)
[Link] = Node(25) [Link](25)
reverseLevelOrderTraversal(root) Ejecutamos la función(raiz)
******************************************************************************************************
*
# Una clase para almacenar un nodo de árbol binario
class Node: clase nodo:
def __init__(self, key=None, left=None, right=None): constr __init__, con los parametros…..
[Link] = key clave = clave
[Link] = left izquierda = izquierda
[Link] = right derecha = derecha
# Atraviese el árbol en orden anticipado y almacene los nodos en un diccionario
# correspondiente a su nivel
def preorder(root, level, d): definine la function(raiz, nivel, d ):
# Caso base: árbol vacío
if root is None: si raiz es Ninguno:
return devuelva
# inserta el nodo actual y su nivel en el diccionario
[Link](level, []).append([Link]) [Link] y predeterminamos(nivel, [])
# recurre para el subárbol izquierdo y derecho aumentando el nivel en 1
preorder([Link], level + 1, d) examinara el dato en el nodo(raí[Link], nivel + 1, d)
preorder([Link], level + 1, d) examinara el dato en el nodo(raí[Link], nivel + 1, d)
# Función recursivo para realizar un recorrido de orden de nivel inverso en un árbol binario
def levelOrderTraversal(root): se crea la función recursiva (raiz):
# crea un diccionario vacío para almacenar nodos entre niveles dados
d = {} d = definimos la lista
# recorrer el árbol e insertar sus nodos en el diccionario
# correspondiente a su nivel
preorder(root, 1, d) examinara el dato en el nodo(raíz, en su correspondiente nivel, diccionario)
# iterar a través del diccionario en orden inverso y
# imprime todos los nodos presentes en todos los niveles
for i in range(len(d), 0, -1): para la variable I en el rango(nos devolverá el valor(diccionario), 0, -1):
print(f'Level {i}:', [Link](i)) imprime(f’ nivel {variable i}:’, [Link] el valor (i) )
if __name__ == '__main__': si, usamos un bloque __variable__ == “__establecemos__”: y usamos el modulo
root = Node(15) raiz = Nodo(15)
[Link] = Node(10) [Link] = Nodo(10) #desde acá nacen los hijo
[Link] = Node(20) [Link] = Nodo(20) #desde acá nacen los hijo
[Link] = Node(8) [Link] = Nodo(8) // //
[Link] = Node(12) [Link] = Nodo(12) // //
[Link] = Node(16) [Link] = Nodo(16) // // //
[Link] = Node(25) [Link] = Nodo(25) // // //
[Link] = Node(30) [Link] = Nodo(30) // // //
levelOrderTraversal(root) ejecutamos la función(raiz)