刷题记录-day5 （二叉树的镜像、从上往下打印二叉树、二叉树中和为某一值、判断是不是平衡二叉树）

二叉树的镜像

class Solution:
    def Mirror(self , pRoot: TreeNode) -> TreeNode:
        # write code here
        # 利用递归的方法，每次都将当前子树的所有左右节点交换
        if not pRoot:
            return None
        pRoot.right, pRoot.left = self.Mirror(pRoot.left),self.Mirror(pRoot.right)
        return pRoot

从上往下打印二叉树

class Solution:
    def PrintFromTopToBottom(self , root: TreeNode) -> List[int]:
        # 是一套遍历二叉树的模板，需要记住
        # 构建两个数组，一个作为最终返回，一个作为先入先出的队列
        # 将队列初始化为根节点，然后每当队列中第一个加入最终返回时，都将这个加入的值的左右子节点加到队列末尾
        # 这样保证了不像递归一样把右子节点的位置挤掉，而是排到后面
        result = []
        if not root:
            return result
        stack = [root]
        while stack:
            temp = stack[0]
            result.append(temp.val)
            stack = stack[1:]
            if temp.left:
                stack.append(temp.left)
            if temp.right:
                stack.append(temp.right)
        return result
            
        # 错误写法！这个题不能用递归方法，因为所有操作并不针对每个子树都独立
        if not root:
            return []
        result = []
        result.extend([root.val])
        result.extend(self.PrintFromTopToBottom(root.left))
        result.extend(self.PrintFromTopToBottom(root.right))
        return result

二叉树中和为某一值的路径（一）

class Solution:
    def hasPathSum(self , root: TreeNode, sum: int) -> bool:
        # write code here
        # 递归方法，主要思想为，将和sum减掉根节点，递归调用函数对两个子树中是否包含（sum-根节点）路径进行判断
        if not root:
            return False
        sum = sum - root.val
        if not root.left and not root.right:
            return True if sum == 0 else False
        left_ = self.hasPathSum(root.left, sum)
        right_ = self.hasPathSum(root.right, sum)
        return (left_ or right_)

判断是不是平衡二叉树

class Solution:
    result = True
    def IsBalanced_Solution(self , pRoot: TreeNode) -> bool:
        # write code here
        # 借鉴之前求二叉树深度的做法，我们只需要判断比较左右子树的高度差是否大于1
        # 使用递归，在每棵小子树也判断是否为平衡二叉树，一旦有小子树不是平衡二叉树就立马返回
        self.high(pRoot)
        return self.result
    
    def high(self,tree):
        if not tree:
            return 0
        l = self.high(tree.left)
        r = self.high(tree.right)
        if abs(l-r) > 1:
            self.result = False
            return -1
        return 1 + max(l,r)