LeetCode之N叉树的最大深度（559）、二叉树的最大深度（104）、二叉树的最小深度（111）

1、N叉树的最大深度（559）

题目描述：

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

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

例如，给定一个 3叉树 :

我们应返回其最大深度，3。

说明:

树的深度不会超过 1000。
树的节点总不会超过 5000。

题目链接

知识点回顾：

此题考察树的深度：

树中所有结点的最大层数， 也称高度。

题解一： 递归法—DFS

1、如果根结点为空，则返回0；
2、如果根结点有孩子，递归调用函数依次求孩子的深度，返回（孩子深度的最大值+1）；
3、否则，返回1。

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        if root is None: 
            return 0 
        elif root.children:
            depth_children = [self.maxDepth(node) for node in root.children]
            return max(depth_children) + 1 
        else:
            return 1

时间复杂度：O(N)，其中N为树中结点总数
空间复杂度：O（N）

题解二： 迭代法

1、使用深度优先搜索策略访问每个节点，同时更新每次访问时的最大深度。
2、可以从包含根节点的、对应深度为 1的栈开始。
3、然后继续迭代，从栈中弹出当前节点并将子节点压入栈中，每次都更新对应深度。

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        stack=[]
        if root:
            stack.append((1,root))
        depth=0
        while stack:
            cur_depth,root=stack.pop()
            if root:
                depth=max(depth,cur_depth)
            for c in root.children:
                stack.append((cur_depth+1,c))
        return depth

时间复杂度：O(N)，其中N为树中结点总数
空间复杂度：O（N）

2、二叉树的最大深度（104）

题目描述：

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

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

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

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

题目链接
题解一： 递归法—DFS

1、如果根结点为空，则返回0；
2、否则，递归调用函数依次求左、右孩子的深度，返回（孩子深度的最大值+1）；

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

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1

时间复杂度：$O(n)$，其中 n 为二叉树节点的个数。每个节点在递归中只被遍历一次。
空间复杂度：$O(\text{height})$，其中 $\text{height}$表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

3、二叉树的最小深度

题目描述：

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

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

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

示例:

给定二叉树 [3,9,20,null,null,15,7],

返回它的最小深度 2.
题解一： 递归法—DFS
思路：

1、如果根结点为空，则返回0；
2、否则，递归调用函数依次求左、右子树的深度，返回（左、右子树深度的最小值+1）；
但是有一点需要注意

• 如果左子树深度、右子树深度均不为0或者都为0，则用min取其中最小值

• 但如果左右子树深度一个为空一个不为空，就会有问题了，因为为空的那个子节点的深度是0，我们不能用它，所以这里要有个判断：

  • 如果左子树深度为0，则返回右子树的深度+1；
  • 如果右子树深度为0，则返回左子树的深度+1；

比如下面7的左子树的深度是0，但他还有右子树，所以我们不能选择深度最小的（因为这时7的左子树的深度是0）。应该返回右子树的深度加一。

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

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        # 如果左子树等于空，我们返回右子树的最小高度+1
        elif root.left is None:
            return self.minDepth(root.right)+1
        # 如果右子树等于空，我们返回左子树的最小高度+1
        elif root.right is None:
            return self.minDepth(root.left)+1
        # 如果左右子树都不为空，我们返回左右子树深度最小的那个+1
        return min(self.minDepth(root.left),self.minDepth(root.right))+1