小白试水——leetcode腾讯题库-104.二叉树的最大深度（Python解答）

题目104：二叉树的最大深度

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

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

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

示例：

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

方法一：递归

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/er-cha-shu-de-zui-da-shen-du-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

树的定义

首先，给出我们将要使用的树的结点 TreeNode 的定义。

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

算法

直观的方法是通过递归来解决问题。在这里，我们演示了 DFS（深度优先搜索）策略的示例。

class Solution:
    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 是结点的数量。
空间复杂度：
在最糟糕的情况下，树是完全不平衡的，例如每个结点只剩下左子结点，递归将会被调用 N 次（树的高度），因此保持调用栈的存储将是 O(N)。但在最好的情况下（树是完全平衡的），树的高度将是 log(N)。因此，在这种情况下的空间复杂度将是 O(log(N))。

方法二：迭代

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/er-cha-shu-de-zui-da-shen-du-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

我们还可以在栈的帮助下将上面的递归转换为迭代。

我们的想法是使用 DFS 策略访问每个结点，同时在每次访问时更新最大深度。

1. 解救小哈——DFS算法举例 - Zoctopus_Zhang - 博客园 https://www.cnblogs.com/OctoptusLian/p/7429645.html
2. DFS(深搜)算法解析 - 江北绝尘 - CSDN博客 https://blog.csdn.net/wumingkeqi/article/details/70940978
3. 算法分析 | 一文理解搜索算法-彻底入门DFS - 知乎 https://zhuanlan.zhihu.com/p/41307874

所以我们从包含根结点且相应深度为 1 的栈开始。然后我们继续迭代：将当前结点弹出栈并推入子结点。每一步都会更新深度。

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """ 
        stack = []
        if root is not None:
            stack.append((1, root))
        
        depth = 0
        while stack != []:
            current_depth, root = stack.pop()
            if root is not None:
                depth = max(depth, current_depth)
                stack.append((current_depth + 1, root.left))
                stack.append((current_depth + 1, root.right))
        
        return depth

复杂度分析

时间复杂度：O(N)。
空间复杂度：O(N)。

方法三：map函数（递归）

作者：knifezhu
链接：https://leetcode-cn.com/problems/two-sum/solution/1-xing-python-by-knifezhu/
来源：力扣（LeetCode）

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

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        return max(map(self.maxDepth,(root.left, root.right))) + 1 if root else 0

方法四：递归/广度优先搜索/深度优先搜索

作者：wanlaitianyuxue
链接：https://leetcode-cn.com/problems/two-sum/solution/er-cha-shu-de-zui-da-shen-du-by-wanlaitianyuxue/
来源：力扣（LeetCode）

思路

1. 递归：根节点对应的最大深度是左右子树最大深度的最大值加一。

2. 广度优先搜索： 广度优先搜索最后到达的叶子节点的是最大深度。

3. 深度优先搜索：记录各节点的深度，通过访问到的叶子节点的深度更新max，直到遍历完成。

实例

递归

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

广度优先搜索

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

深度优先搜索

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0
        
        self.max_level = 1
        self._dfs(root,1)
        return self.max_level
        
    def _dfs(self, node, level):
        if not node: return  
        if level > self.max_level: self.max_level = level
        
        self._dfs(node.left, level + 1)
        self._dfs(node.right, level + 1)