[Series Leetcode] [] [medio] algoritmo binario secuencia de recorrido de árbol (pila, DFS)

tema:

enlaces a los temas:  https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

 

Ideas de resolución de problemas:

Método a: Pila (tiempo O (N), el espacio de O (N))

Variables:

1. apilar: la pila cuando el recorrido, la inicialización, sólo el nodo raíz en
2. res: el conjunto de resultados
3. val_lst: La necesidad actual que se añade a la lista de conjunto de resultados

proceso:

inicialización pila, el nodo raíz 3 en la pila, y después de atravesar:

Get se encontró el primer elemento de pila, poner en val_lst en este caso y el izquierdo y derecho 3 subárboles puesta en la pila

Y en este punto se ha atravesado en el inicio de recorrido es de todos los elementos en la pila, fuera de esta travesía, la val_lst valor se coloca en la res:

Continuando desplazamiento, obtener el primer elemento de la pila 2, el 2 val_lst y poner en la pila, entonces los subárboles izquierdo y derecho de la pila 2:

9 continuarán val_lst colocado en la pila 9, 9 porque no hay subárboles izquierdo y derecho, elementos de la pila no tiene que añadir

En este punto esto se ha atravesado todos los elementos necesarios para atravesar la salida en el recorrido, la val_lst añadido a las res conjunto de resultados, la próxima vez para continuar para atravesar:

Continuar la caminata hasta que la pila está vacía

 

Método dos: DFS (tiempo O (N), el espacio de O (N))

búsquedas DFS, añaden un nivel de marcado, identificando el valor actual del resultado en caso necesario añadir una capa de

 

la implementación del código:

Método uno:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        
        stack = [root]
        res = []
        while stack:
            val_lst = []
            for index in range(0, len(stack)):
                node = stack[0]
                stack.pop(0)
                val_lst.append(node.val)
                if node.left:
                    stack.append(node.left)
                    
                if node.right:
                    stack.append(node.right)
                    
            res.append(val_lst)
            
        return res
                
                

 

Segundo método:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        def create_res(res, node, level):
            print(res)
            if not node:
                return res
            
            if len(res) == level:
                res.append([])
                
            res[level].append(node.val)
            if node.left:
                create_res(res, node.left, level + 1)
                
            if node.right:
                create_res(res, node.right, level + 1)
                
            return res
        
        return create_res([], root, 0)