代码训练营 Day14 | 226.翻转二叉树 | 101. 对称二叉树 | 104.二叉树的最大深度 | 111.二叉树的最小深度

226.翻转二叉树

1. 两两交换左右孩子，注意这里交换的是他们的指针，最后达到翻转二叉树
2. 使用深度搜索:
   1. 前 & 后序遍历可以完美解决
   2. 前序遍历顺序: 中左右
   3. 后续遍历顺序: 左右中
3. 对于中间遍历的时候，我们这里应该做的操作是把左右孩子指针进行交换
4. 初次之外写这道题目用到的是递归我们牢记递归三部曲:
   1. 确定递归函数的参数和返回值
   2. 确定递归的终止条件
   3. 确定递归每一层递归的逻辑

# 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
        
        we need swap two child node
        """
        # pre order traversal order: middle left right

        # 1. determine the function arguments,and return value
        def dfs(node):
            # 2. determine recrusion stop condition
            if node == None:
                return node
            
            # 3. determine each recursion logic 

            # sawp two node left and right children
            node.left, node.right = node.right, node.left # middle
            dfs(node.left)  # left
            dfs(node.right) # right

        dfs(root)

        return root    

101. 对称二叉树

1. 判断二叉树时候对称，本质就是判断左子树跟右子树是否可以相互翻转
2. 如果左子树和右子树可以相互翻转的话证明此树是可对称的
3. 判断左右子树是否可以翻转:
   1. 同是内侧的节点进行比较，同是外侧的节点进行比较
   2. 外侧和内测节点都相同说明可以翻转
4. 使用后序遍历: 左右中(遍历顺序)
   1. 在递归的时候停止条件需要注意:
      1. 左右节点有一个为空，我们要返回false;

      2. 左右都为空，返回True；说明两个数节点一样可能是可以相互翻转

      3. 左右都不为空，值不相等,返回false;

      4. 节点左右都不为空，值也相等，这时应该向下继续遍历

   2. 因为我们要收集左右孩子的信息返回给上一个节点，重复这个操作

   3. 我们才能知道以左节点为根节点的这颗树和以右节点为根节点的这颗树，是否是相互翻转的

   4. 以我们根节点出发，只有我们先收集完了左右孩子的信息，返回给根节点我们才能进行判断是否是可以翻转的

# 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:
            # it's empty tree, which it's symmetric
            return True
        
        return self.compare(root.left,root.right)
    
    def compare(self,left,right):
        # determine recursion end condition
        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
        
        #  compare left and right children is same or not
        outside = self.compare(left.left,right.right) # left traversal
        inside = self.compare(left.right,right.left) # right traversal
        # compare if the left and right sub tree can be flip or not
        result = outside and inside # middle traversal

        return result

104.二叉树的最大深度(递归 后序遍历实现)

深度:

    1. 二叉树里边任意一个节点到根节点的距离

    2. 深度从1开始从root开始计算

高度:

    1. 二叉树中任意一个节点到叶子节点的距离

    2. 从叶子节点开始，叶子节点的高度是1

使用后序遍历做这道题也是可以的:

        1. 遍历顺序: 左右中

        2. 先遍历左右两边子树，中是用来处理条件去找到最大深度

# 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
        """
       

        def dfs(node):
            # if root is empty,then depth is 0
            if node == None:
                return 0
          
            # use post order traversal: left right middle
            leftHeight = dfs(node.left)
            rightHeight = dfs(node.right)
            height = 1+max(leftHeight,rightHeight)

            return height

        height = dfs(root)
        return height

111. 二叉树最小深度（后序遍历 递归）

1. 思路跟最大深度类似不过在做中遍历的时候处理条件需要注意
   1. 如果左子树为空右子树不为空的情况；返回1+右子树最小深度
   2. 如果右子树为空左子树不为空的情况；返回1+左子树最小深度
   3. 如果两个子树都不为空；返回1+min（左右子树）

# 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
        """
        
        def dfs(node):
            # root is empty return 0
            if node == None:
                return 0

            # use post order traversal
            leftheight = dfs(node.left)     # left
            rigtheight = dfs(node.right)   # right
            # middle  procese different condition for left and right sub tree
            if node.left == None and node.right != None:
                # left tree met none, but right doesn't
                return 1+rigtheight
            if node.left != None and node.right == None:
                return 1+leftheight
            
            # both sub tree are not empty
            result = 1+min(leftheight,rigtheight)
            return result
        
        result = dfs(root)

        return result