代码随想录算法训练营第十四天｜226. 翻转二叉树、101. 对称二叉树、104. 二叉树的最大深度、111. 二叉树的最小深度

如何判断是不是要使用递归：看子问题是不是有相同的处理逻辑
递归三步法：1.确定终止条件 2.递归内的逻辑 3.递归

226. 翻转二叉树

leetcode 226. 翻转二叉树
代码随想录

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        def invert(root):
            if root == None: # 边界条件
                return 
            # 交换
            temp = root.left
            root.left = root.right
            root.right = temp
            # 递归
            invert(root.left)
            invert(root.right)
        invert(root)
        return root

101. 对称二叉树

leetcode 101. 对称二叉树
代码随想录

使用两个指针一个向左，一个向右同时遍历树；比较两个节点是不是相同。终止条件1.不同2.叶子节点（最终的）； 然后递归的时候，左和右比较，右和左比较。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root == None:
            return True
        def compare(node1, node2):
            if node1 == None and node2 != None:
                return False
            elif node1 != None and node2 == None:
                return False
            elif node1 == None and node2 == None:
                return True
            elif node1.val != node2.val:
                return False
            condition1 = compare(node1.left, node2.right)
            condition2 = compare(node1.right, node2.left)
            return condition1 and condition2
        return compare(root.left, root.right)

104. 二叉树的最大深度

leetcode 104. 二叉树的最大深度
代码随想录

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def deep(root):
            if root == None: # 到达叶子节点，返回0
                return 0
            return max(deep(root.left), deep(root.right))+1 # 左右最大的+1
        return deep(root)
        

111. 二叉树的最小深度

leetcode 111. 二叉树的最小深度
代码随想录

最小深度一开始用和最大深度一样的写法，结果解答错误，是因为没搞清楚min(left,right)这个不一定是找到的叶子节点，比如example中的偏二叉树。
所以需要增加条件1.如果左右孩子，那就是叶子节点 返回1；2.如果只有左（右）子树，那就返回右（左）子树的最小高度+1

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        def deep(root):
            # 一开始的错误解法
            # if root == Nonoe:
                # return 0
            # return min(left, right) +1
            if root.left == None and root.right == None:
                return 1
            elif root.left == None:
                return deep(root.right) + 1
            elif root.right == None:
                return deep(root.left) + 1
            return min(deep(root.left), deep(root.right)) + 1
        return deep(root)