代码随想录算法训练营day13| 226.翻转二叉树 101.对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

学习资料：https://programmercarl.com/0226.翻转二叉树.html#算法公开课

今天都用递归法，三思（返回值；终止条件；处理逻辑）
前/中/后序遍历方法要仔细辨别
选取的226用前序遍历，后三道用后续遍历
二叉树深度：根节点为1，其余节点与根节点相比，越下越大
二叉树高度：叶子节点为1，其余节点与叶子节点相比，越上越大

学习记录：
226.翻转二叉树（递归；返回根节点；到Null终止；前序：根左右）

点击查看代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None


        # 递归法，前序遍历
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root
        
        # # 层序遍历，前序
        # queue = collections.deque([root])
        # while queue:
        #     size = len(queue)
        #     for i in range(size):
        #         node = queue.popleft()
        #         node.left, node.right = node.right, node.left
        #         if node.left:
        #             queue.append(node.left)
        #         if node.right:
        #             queue.append(node.right)
        # return root

101.对称二叉树（递归法；返回True/False；后序：左右根；终止条件：1当左空右不空，False，2当左不空右空，False，3当左空右空，True，4当左不空右不空但值不等，False，
5当左=右要判断外侧是否相等，内侧是否相等，再更加这两个情况返回最终结果）

点击查看代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        return self.compare(root.left, root.right)    # 调用compare函数
        

    def compare(self, left, right):
        # 终止条件：1左不空有空，2左空右不空，3左空右空，4左不空右不空但不等
        if left != None and right == None:
            return False
        elif left == None and right != None:
            return False
        elif left == None and right == None:
            return True
        elif left.val != right.val:
            return False
        
        # 递归法
        # 当左右值相等，判断内外子树分别是否相等，将结果isSame传给root
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        isSame = outside and inside
        
        # 只有内子树相等且外子树相等时，返回True
        return isSame

104.二叉树的最大深度（递归法；最大深度等于根节点的最大高度，所以添加一个函数来求节点高度，根节点的子树高度+1=根节点高度；返回最大深度；到Null终止；后序遍历：左右根）

点击查看代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.getheight(root)

    def getheight(self, node):
        """
        递归法求高度；
        这里高度和深度有个互通之处：根节点的高度等于二叉树的最大深度
        """
        # 当节点为空，则是叶子节点的下一位，又因为叶子节点的高度为1，则该节点的高度为0
        if not node:
            return 0
        # 递归法：后序遍历，先求左右孩子各自的高度，节点高度=左右孩子的高度最大值加1
        left_height = self.getheight(node.left)
        right_height = self.getheight(node.right)
        node_height = 1 + max(left_height, right_height)
        return node_height

111.二叉树的最小深度（递归法；返回最小深度；终止条件：1当节点为空返回0，2当左空右不空返回右+1，3当左不空右空返回右+1，4返回min(左，右)+1；后序遍历：左右根）

点击查看代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.getheight(root)


    def getheight(self, node):
        """
        求最小深度也是求根节点的最小高度，关键在于：
        在此题中，当左孩子或者右孩子为空时，不能认为这是最小高度，要选非空那个孩子的高度；
        1 + 左孩子或者右孩子高度 = 节点高度
        """
        if not node: # 该节点为空则为叶子节点的下一位，高度为0
            return 0
        left_h = self.getheight(node.left)
        right_h = self.getheight(node.right)
        if not node.left and node.right:
            return 1+right_h
        elif node.left and not node.right:
            return 1+left_h
        return 1+min(left_h, right_h)