Aprendizaje de la versión Python-LeetCode: 111. La profundidad mínima de un árbol binario

Dado un árbol binario, encuentre su profundidad mínima.

La profundidad mínima es el número de nodos en la ruta más corta desde el nodo raíz hasta el nodo hoja más cercano.

Explicación: Un  nodo hoja se refiere a un nodo sin nodos secundarios.

Ejemplo: dado un árbol binario [3,9,20, null, null, 15,7],

    3
   / \
  9 20
    / \
   15 7
devuelve su profundidad mínima 2.

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/minimum-depth-of-binary-tree

Método 1: algoritmo BFS, atraviesa los nodos de cada capa desde la raíz, si los nodos secundarios izquierdo y derecho del nodo están vacíos, vuelve a la profundidad en este momento

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

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if  not root: return 0

        depth=1

        queue=[]
        queue.append(root)
        
        while queue !=[]:
            for i in range(len(queue)):
                # 获取进入队列的第一个节点
                cur = queue.pop(0)
                # 判断左右子树是否为空
                if (cur.left is None) and (cur.right is None):
                    return depth
                # 判断左右子树不为空时，加入队列
                if cur.left is not None:
                    queue.append(cur.left)
                if cur.right is not None:
                    queue.append(cur.right)
            depth+=1
        
        return depth

Método 2: Utilice un algoritmo recursivo, que atraviesa los subárboles izquierdo y derecho de la raíz para determinar cuál de los subárboles izquierdo y derecho tiene la profundidad más pequeña. No es necesario atravesar la cola de almacenamiento temporal en el medio, que es más simple que el método 1 y más rápido en eficiencia.

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        # 左子树不为空，遍历右子树，深度加1
        if not root.left: return 1 + self.minDepth(root.right)
        # 右子树不为空，遍历左子树，深度加1
        if not root.right: return 1 + self.minDepth(root.left)
        # 还回左右子树总深度最小的值
        return 1 + min(self.minDepth(root.left), self.minDepth(root.right))