Leetcode104. 二叉树的最大深度 Maximum Depth of Binary Tree - Python 以迭代/递归法解题

#迭代法
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        results = []
        queue = deque([root])

        while queue:
            child_size = len(queue)
            result = []
            for _ in range(child_size):
                cur = queue.popleft()
                result.append(cur.val)
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
            results.append(result)
        return len(results)

层序遍历法1-迭代思想：

同迭代层序遍历二叉树

# 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
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        depth = 0
        queue = collections.deque()
        queue.append(root)
        while queue:
            depth += 1
            for i in range(len(queue)):
                node = queue.popleft()
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return depth

层序遍历法2-迭代思想：

#递归法
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0

        result = []
        self.res = 0
        def Traversal(root: TreeNode, depth = 0):
            if len(result) == depth: result.append([])
            if root.left: Traversal(root.left, depth + 1)
            if root.right: Traversal(root.right, depth + 1)
            self.res = max(self.res, depth + 1)
        Traversal(root, 0)
        return self.res

层序法：递归法思路：

注意全局变量self.res的使用，以及depth+1 因为深度和depth始终差1

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

依次求左右子树深度，取最大即为原数的深度。递归法