代码随想录day17

第一题

遍历方法：后续遍历，none节点停止

思路：本质上求每个节点的最大深度（1+max）逻辑

但是当：

左子树已经不是平衡

右子树已经不是平衡

本节点为根节点的数计算后不是平衡，返回-1

核心代码和求最大高度一样，添加三种逻辑

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if self.getheight(root)!=-1:
            return True
        else:
            return False
    #需要返回高度
    def getheight(self,node):
        if node is None:
            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:
            #需要求深度
            return 1+max(leftheight,rightheight)
        else:
            return -1

第二题

遍历方法：前序遍历，叶子节点停止（前序遍历在停止逻辑之前）

思路：

if 左节点存在：（条件）

递归函数（递归）

pop（回溯）

回溯和递归在一个层级

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        path=[]
        result=[]
        self.search(root,path,result)
        return result

    def search(self,node,path,result):
        #前
        path.append(node.val)    
        if node.left is None and node.right is None:
            # 终止条件，找到叶子节点。在到达叶子节点后，转换、添加结果
            sPath = '->'.join(map(str, path))
            result.append(sPath)
            return 
        #左
        if node.left:
            self.search(node.left,path,result)
            path.pop()
        #右
        if node.right:
            self.search(node.right,path,result)
            path.pop()

第三题：

遍历方法：前序遍历，none停止（求和类型）

思路：当遇到左叶子节点的时候，记录数值（旨在这种情况下记录），然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

 def sumOfLeftLeaves(self, root):
        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