(十四)|110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和

110.平衡二叉树 

给定一个二叉树，判断它是否是高度平衡的二叉树。

一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

所以这道题就是比较左右子树的高度差，涉及到求高度，用后序遍历。

递归三步曲分析：

1.明确递归函数的参数和返回值

参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。

那么如何标记左右子树是否差值大于1呢？

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。

所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

2.明确终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0

3.明确单层递归的逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

 

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 isBalanced(self, root):
        if self.getheight(root)==-1:
            return False
        else:
            return True
        
    def getheight(self,node):
        if not node:
            return 0
        leftheight=self.getheight(node.left)
        rightheight=self.getheight(node.right)
        if leftheight==-1:
            return -1
        if rightheight==-1:
            return -1
        if(abs(rightheight-leftheight)>1):
            return -1
        else:
            return 1+max(leftheight,rightheight)
        

257. 二叉树的所有路径 

给定一个二叉树，返回所有从根节点到叶子节点的路径。

这道题目要求从根节点到叶子的路径，需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

递归三部曲：

1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path，和存放结果集的result

2.确定递归终止条件

找到叶子节点，就开始结束的处理逻辑了（把路径放进result里）。

那么什么时候算是找到了叶子节点？ 是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。

3.确定单层递归逻辑

因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。

path.append(cur.val);

然后是递归和回溯的过程，上面说过没有判断cur是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。所以递归前要加上判断语句，判断下面要递归的节点是否为空.

递归完，要做回溯，因为path 不能一直加入节点，它还要删节点，然后才能加入新的节点。回溯和递归是一一对应的，有一个递归，就要有一个回溯。

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 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)
        if cur.left:  # 左
            self.traversal(cur.left,path,result)
            path.pop()  # 回溯
        if cur.right:  # 右
            self.traversal(cur.right,path,result)
            path.pop()  # 回溯

    def binaryTreePaths(self, root):
        result=[]
        path=[]
        if not root:
            return result
        self.traversal(root,path,result)
        return result
        

map(str, path): 使用map函数将路径path中的每个节点值转换为字符串。这是因为 join 方法要求序列中的元素都是字符串类型。

'->'.join(...): 使用箭头 "->" 将经过 map 转换的字符串连接起来。这将创建一个包含路径中所有节点值的字符串，每个节点值之间用 "->" 分隔。

例:假设 path 中的节点值是 [1, 2, 3]，那么经过 map(str, path) 将得到 ['1', '2', '3']，然后通过 '->'.join(...) 将这些字符串连接起来，得到最终的字符串 '1->2->3'。

404.左叶子之和 

计算给定二叉树的所有左叶子之和。

左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。

判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。

如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子

递归三部曲：

1.确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和

2.确定终止条件

如果遍历到空节点，那么左叶子值一定是0

注意，只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0(这部分代码写不写都行，如果不写不影响结果，但就会让递归多进行了一层)

3.确定单层递归的逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

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 sumOfLeftLeaves(self, root):
        if not root:  # 如果是空节点，其左子叶为0
            return 0
        if not root.left and not root.right:  # 如果是叶子节点，其左子叶之和为0
            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=leftvalue+rightvalue
        return sum        

class Solution(object):
    def sumOfLeftLeaves(self, root):
        if not root:
            return 0
        if not root.left and not root.right:  # 如果是叶子节点，其左子叶之和为0
            return 0
        if root.left and not root.left.left and not root.left.right:   # 找到左叶子节点
            value=root.left.val  # 处理根节点的左子节点就是左叶子节点的情况
        leftvalue=self.sumOfLeftLeaves(root.left)
        rightvalue=self.sumOfLeftLeaves(root.right)
        sum=value+leftvalue+rightvalue
        return sum