Preorder recorrido del árbol binario de Leetcode

0 descripción del tema

Enlace al título original de Leetcode: Preorder recorrido del árbol binario
Inserte la descripción de la imagen aquí

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

1 solución recursiva

Primera búsqueda en profundidad (DFS)

En esta estrategia, usamos la profundidad como prioridad para comenzar desde la raíz y llegar a una hoja determinada, y luego regresar a la raíz para llegar a otra rama.
La estrategia de búsqueda en profundidad se puede subdividir en recorrido de preorden, recorrido de orden medio y recorrido de posorden según el orden relativo del nodo raíz, el elemento secundario izquierdo y el secundario derecho.

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

Complejidad del algoritmo Complejidad del
tiempo: $O (n)$ , donde $n$ es el número de nodos de árbol binario. En el recorrido del árbol binario, cada nodo será visitado una vez y solo una vez.
Complejidad espacial: $O (n)$ . La complejidad del espacio depende de la profundidad de la pila recursiva, y la profundidad de la pila puede alcanzarcuando el árbol binario es una cadenaNivel $O$ $($ $n$ $)$ .

2 Solución iterativa (pila)

Primera búsqueda de amplitud (BFS)

Visitamos todo el árbol capa por capa en orden de altura, y los nodos de nivel superior se visitarán antes que los de nivel inferior.

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        White, Gray = 0, 1
        res = []
        stack = [(White,root)]
        while stack:
            color, node = stack.pop()
            if not node: continue
            if color == White:
                stack.append((White,node.right))
                stack.append((White,node.left))
                stack.append((Gray,node))
            else:
                res.append(node.val)
        return res

Complejidad del algoritmo Complejidad del
tiempo: visite cada nodo exactamente una vez, la complejidad del tiempo es $O (N)$ , donde $N$ es el número de nodos, que es el tamaño del árbol.
Complejidad del espacio: depende de la estructura del árbol, el peor caso es almacenar el árbol completo, por lo que la complejidad del espacio es $O (N)$ 。

3 recorrido de preorden de Morris

El método se basa en el artículo de Morris y puede optimizar la complejidad del espacio. El algoritmo no utiliza espacio adicional, solo se debe guardar el resultado final de salida. Si el resultado se emite en tiempo real, la complejidad del espacio es $O (1)$ 。

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        node, res = root, []
        while node:  
            if not node.left: 
                res.append(node.val)
                node = node.right 
            else: 
                pre = node.left 
                while pre.right and pre.right is not node: 
                    pre = pre.right 
                if not pre.right:
                    res.append(node.val)
                    pre.right = node  
                    node = node.left  
                else:
                    pre.right = None
                    node = node.right         
        return res

Complejidad del algoritmo Complejidad del
tiempo: $O (n)$ , donde $n$ es el número de nodos en el árbol de búsqueda binaria. En el recorrido de Morris, cada nodo se visitará dos veces, por lo que la complejidad del tiempo total es $O (2 n)$ = $O (n)$ .
Complejidad espacial: $O (1)$ 。

Referencia

Recorrido en orden del árbol binario: Python implementa tres soluciones
Leetcode