代码营打卡 Day17

1. 平衡二叉树

平衡二叉树就是看任何节点的左右子树高度差是否不超过1, 求高度考虑用后序遍历的递归来做

首先考虑参数和返回值, 参数就是当前传入的根节点, 返回值就是以当前传入节点为根节点的树的高度. 如果当前传入节点为根节点的二叉树已经不是平衡二叉树, 就不需要返回高度了, 直接返回-1即可

然后是终止条件, 递归过程中遇到了空节点就终止, 返回0, 表明当前节点的高度为0

单层递归的逻辑是看左右子树的差值是否小于1, 如果不小于就返回-1, 否则返回当前二叉树的高度

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if self.getheight(root) == -1:
            return False
        return True

    def getheight(self, node):
        if not node:
            return 0

        leftheight = self.getheight(node.left)
        if leftheight == -1:
            return -1

        rightheight = self.getheight(node.right)
        if rightheight == -1:
            return -1

        if abs(leftheight-rightheight)>1 :
            result = -1
        else:
            result = 1+max(leftheight, rightheight)
        return result

2. 二叉树的所有路径 

这道题即是用一个path记录一条路径, 并且用result存储所有可能的路径, 目的是要求我们记录所有从根节点到叶子节点的路径

首先确定递归函数的参数与返回值, 要传入根节点root, 记录每条路径的path和存放结果集的result. 递归的终止条件是收集到路径的叶子节点结束, 是叶子节点而不是空节点, 所以当cur不为空, 但左右孩子都为空的时候终止

然后是确定单层递归逻辑, 因为路径是父节点指向孩子节点, 所以考虑用前序来解决, 先处理中间节点, 这个中间节点的处理要放在判断cur是否为叶子节点之前, 因为判断了以后, 如果不是叶子节点, 就直接return, 那么就无法将叶子节点加入path中

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        result = []
        path =[]
        if not root:
            return result
        self.traversal(root, path, result)
        return result 
    
    def traversal(self, cur, path, result):
        path.append(cur.val)
        if not cur.left and not cur.right:
            sPath = '->'.join(map(str, path))
            result.append(sPath)
            return
        if cur.left:
            self.traversal(cur.left, path, result)
            path.pop()
        if cur.right:
            self.traversal(cur.right, path, result )
            path.pop()

    1
   / \
  2   3
 / \
4   5

假设有这么一个二叉树 开始path 和result为空, 遍历根节点1, 加入path, 由于1有左子树, 调用traversal(2, [1], result). 遍历根节点2, 加入path, 变成path = [1, 2], 由于2有左子树, 调用self.traversal(4, [1, 2], result), 将4添加入path, path= [1,2,4], 由于4是叶子节点, 所以将path转换为字符串并添加到result

然后将4从path中弹出, path变为[1,2]. 返回节点2 , 存在右子树, 所以调用traversal(5, [1,2], result), 遍历5

3. 左叶子之和(404)

左叶子就是叶子节点且是其父节点的左节点, 求出这些和. 用左子树的左叶子之和加上右子树的左叶子之和, 那么考虑用后序遍历

首先确定参数和返回值, 传入根节点, 返回值为数值之和,. 注意只有当前遍历的节点是父节点, 才能判断子节点是不是左叶子, 如果当前遍历的是叶子节点, 那么左叶子为0

单层递归的逻辑是左子树左叶子之和加上右子树的左叶子之和

class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        if root.left is None and root.right is None:
            return 0
            
        leftValue = self.sumOfLeftLeaves(root.left)  # 左
        if root.left and not root.left.left and not root.left.right:  # 左子树是左叶子的情况
            leftValue = root.left.val
            
        rightValue = self.sumOfLeftLeaves(root.right)  # 右

        sum_val = leftValue + rightValue  # 中
        return sum_val