3.24_二叉树

1.返回树的深度

1. 层次遍历

2. 递归

class Solution:
    def TreeDepth(self , pRoot: TreeNode) -> int:
        # write code here
        if not pRoot:
            return 0
        left = right = 0
        if pRoot.left:
            left = self.TreeDepth(pRoot.left)
        if pRoot.right:
            right = self.TreeDepth(pRoot.right)
#         return max(left,right)+1
        if left > right:
            return left+1
        else:return right+1

2.二叉树的镜像

• 左右子树交换 
• 递归改变pRoot为根节点的子节点

class Solution:
    def Mirror(self , pRoot: TreeNode) -> TreeNode:
        # write code here
        if pRoot:
            # 左右子树交换
            pRoot.left,pRoot.right = pRoot.right,pRoot.left
            # 递归改变pRoot为根节点的子节点
            self.Mirror(pRoot.left)
            self.Mirror(pRoot.right)
        return pRoot
        if not pRoot:
            return pRoot

3. 平衡二叉树

1. 计算左右子树的深度
2. 判断左右子树的深度差>1
3. 任意节点的左右子树的深度相差不超过1，就是一棵平衡二叉树
4. 满足任意左右子节点的条件，需要递归函数本身

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        # 计算左右子树的深度
        def treedepth(root):
            if not root: return 0
            return max(treedepth(root.left), treedepth(root.right))+1
        # 判断根节点是否为空
        if not root:
            return True
        # 判断左右子树的深度差
        if abs(treedepth(root.left) - treedepth(root.right)) > 1:
            return False
        # 当前节点的左右子节点接着进入isbalanced()判断
        else:
            # return True 此处不满足任意左右子树深度差不超过1
            return self.isBalanced(root.left) and self.isBalanced(root.right)

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        # 判断左右子树的深度差
        if abs(self.treedepth(root.left) - self.treedepth(root.right)) > 1:
            return False
        # 当前节点的左右子节点接着进入isbalanced()判断
        else:
            # return True 此处不满足任意左右子树深度差不超过1
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        
    # 计算左右子树的深度
    def treedepth(self, root):
        if not root:
            return 0
        return max(self.treedepth(root.left), self.treedepth(root.right))+1

4. 对称的二叉树

找到递归点：左树与右树对称与否，与其跟两树的子树的对称情况有关系。

递归结束条件：

都为空指针则返回 true
只有一个为空则返回 false
两个指针当前节点值不相等 返回false
递归过程：

判断 A 的右子树与 B 的左子树是否对称
判断 A 的左子树与 B 的右子树是否对称

'''
递归判断：
都为空指针则返回 true
只有一个为空则返回 false
两个指针当前节点值不相等 返回false

递归过程：
判断 A 的右子树与 B 的左子树是否对称
判断 A 的左子树与 B 的右子树是否对称
'''

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        # 递归判断
        def helper(a,b):  # 左右子树是否对称
            if not a and not b:  # 左右子树为空
                return True
            if not a or not b: # 左右子树有一个为空
                return False
            if a.val != b.val:  # 左右子树节点的值不相等
                return False
            return helper(a.left,b.right) and helper(a.right,b.left)

        if not root:
            return True
        return helper(root.left,root.right)