LeetCodeWithPython 104. 二叉树的最大深度

题目地址

https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

题目描述

代码初步

• 思路
  因为二叉树在往下的过程中，有两个结点，左节点和右结点。在下一个节点的选择过程中会不好确定到底是选左边，还是选右边。所以我采用的方法是当二叉树的子节点都不是null时，将左右两个结点分别当成新的结点进行下一轮的循环，最后比较左右两边子数的深度，返回深度大的那个，就是整个二叉树的深度了。
• 问题：但在实现的过程中提交超时间限制了

# 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
        """
        LefTree = 1
        RighTree = 1
        if not root:
            return 0
        while root:
            if not root.left and not root.right: # 如果都为空
                break
            elif not root.left and root.right: # 如果左边为空,右边不为空
                RighTree=RighTree+1
                RighTree=self.maxDepth(root.right)
            elif root.left and not root.right: # 如果左边不为空,右边为空
                LefTree=LefTree+1
                LefTree = self.maxDepth(root.left)
            else:
                LefTree = self.maxDepth(root.left)
                RighTree = self.maxDepth(root.right)
        return max(LefTree,RighTree)

代码欣赏

• 方法一：递归
  
  复杂度分析：
• 时间复杂度：我们每个结点只访问一次，因此时间复杂度为 O(N)， 其中 N是结点的数量。
• 空间复杂度：在最糟糕的情况下，树是完全不平衡的，例如每个结点只剩下左子结点，递归将会被调用 N 次（树的高度），因此保持调用栈的存储将是 O(N)。但在最好的情况下（树是完全平衡的），树的高度将是 log(N)。因此，在这种情况下的空间复杂度将是 O(log(N))。

# 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 not root:
            return 0
        else:
            LefTree = self.maxDepth(root.left)
            RighTree = self.maxDepth(root.right)
            return max(LefTree,RighTree)+1

• 方法二：迭代
  还可以在栈的帮助下将上面的递归转换为迭代。
  我们从包含根结点且相应深度为 1 的栈开始。然后我们继续迭代：将当前结点弹出栈并推入子结点。每一步都会更新深度。

复杂度分析：

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

# 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
        """ 
        stack=[]
        depth=0
        if root is not None:
        	stack.append((1, root))
        	
        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