leetcode树之树的深度

104、二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

---

递归方法：

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

迭代方法：

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        queue = [root]
        level = 0
        while queue:
            n = len(queue)
            for i in range(n):
                cur = queue.pop(0)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            level += 1
        return level

111、二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

示例1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

---

递归：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        if not root.left and not root.right: return 1
        # 由于这里是求最小值，所以要考虑没有只有一个子节点的情况
        if root.left and root.right:
            depth = min(self.minDepth(root.left), self.minDepth(root.right))
        else:
            depth = self.minDepth(root.left) or self.minDepth(root.right)
        return depth + 1

迭代

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        queue = [root]
        level = 0
        while queue:
            n = len(queue)
            level += 1
            for i in range(n):
                cur = queue.pop(0)
                # 如果当前子节点没有子节点，直接返回。由于是层序遍历，那么这时leve就是最小深度
                if not cur.left and not cur.right:
                    return level
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
        return level

559、N叉树的最大深度

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）

示例1：

输入：root = [1,null,3,2,4,null,5,6]
输出：3

示例2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

---

递归：

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root: return 0
        if not root.children: return 1
        return max(self.maxDepth(child) for child in root.children) + 1

迭代：

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root: return root
        queue = [root]
        level = 0
        while queue:
          	level += 1
            # 此为简写形式，也可写成下方注释代码
            queue = [child for node in queue if node.children for child in node.children]
            # n = len(queue)
            # for i in range(n):
            #     cur = queue.pop(0)
            #     if not cur.children: continue
            #     for child in cur.children:
            #         queue.append(child)
        return level