代码随想录算法训练营第十七天|110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和

110.平衡二叉树

思路：

平衡二叉树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

此时大家应该明白了既然要求比较高度，必然是要后序遍历。

递归三步曲分析

1. 明确递归函数的参数和返回值
2. 明确终止条件
3. 明确单层递归的逻辑

代码：

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.getheight(root) != -1 # 如果getheight方法返回的不是-1，则isBalanced方法返回True，表示树是平衡的；否则返回False，表示树不平衡
    
    def getheight(self,node):
        if not node: # 如果传入的节点node是None（即已经到达叶子节点的下方），则返回0，表示该子树的高度为0
            return 0
            
        # 使用递归调用getheight方法分别计算当前节点的左子树和右子树的高度(每次递归调用都有可能返回两种情况：1.子树的高度（一个非负整数），这表示子树是平衡的，并且返回了它的实际高度。2.-1，这表示子树不是平衡二叉树。当子树不是平衡二叉树时，递归调用会立即返回-1，并且这个-1会向上层递归传递，最终导致整个树被认为是不平衡的（如果根节点的递归调用返回-1）。
        leftheight=self.getheight(node.left)
        rightheight=self.getheight(node.right)
        
        if abs(leftheight - rightheight) > 1 or leftheight == -1 or rightheight == -1: # 如果leftheight或rightheight中任何一个为-1，说明对应的子树不平衡，因此整个树也不平衡，直接返回-1。如果leftheight和rightheight的差的绝对值大于1，说明左右子树高度差超过了允许的范围，树不平衡，返回-1。
            return -1
        else: # 如果树是平衡的（即通过了上述的检查），则计算当前树的高度为左右子树中较高的一棵的高度加1，并返回这个高度。
            height=max(leftheight,rightheight)+1
            return height

时间复杂度：O(n)

空间复杂度：O(n)

257. 二叉树的所有路径 

思路：

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

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

前序遍历以及回溯的过程如图：

 

我们先使用递归的方式，来做前序遍历。要知道递归和回溯就是一家的，本题也需要回溯。 

递归三部曲：
1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值

2.确定递归终止条件

在写递归的时候都习惯了这么写

 if not node: 
    终止处理逻辑

但是本题的终止条件这样写会很麻烦，因为本题要找到叶子节点，就开始结束的处理逻辑了（把路径放进result里）。

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

所以本题的终止条件是：

if not cur.left and not cur.right: 
    sPath = '->'.join(map(str, path)) 
    result.append(sPath) 
    return None 

3.确定单层递归逻辑

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

path.append(cur.val)

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

if cur.left: 
    self.traversal(cur.left, path, result)
    path.pop() 
if cur.right:
    self.traversal(cur.right, path, result)
    path.pop()

代码：

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = [] # 初始化一个空列表result，用于存储最终的路径结果
        path = [] # 初始化一个空列表path，用于存储当前遍历路径上的节点值
        if not root: # 如果根节点为空（即二叉树为空），则直接返回空的结果列表
            return result
        self.traversal(root, path, result) # 调用辅助方法traversal来遍历二叉树并生成路径
        return result # 返回存储了所有路径的result列表
    
    def traversal(self, cur, path, result):
        path.append(cur.val)  # 中，将当前节点的值添加到path列表中
        if not cur.left and not cur.right:  # 判断当前节点是否为叶子节点（即没有左子节点和右子节点）
            sPath = '->'.join(map(str, path)) # 将path列表中的所有节点值转换为字符串，并使用->连接，生成一个完整的路径字符串
            result.append(sPath) # 将生成的路径字符串添加到result列表中
            return None # 结束当前叶子节点的处理，并返回
        if cur.left:  # 左，判断当前节点是否有左子节点
            self.traversal(cur.left, path, result) # 递归调用traversal方法继续遍历左子树
            path.pop()  # 回溯，将当前节点从path列表中移除，以便在下一次递归调用中能够正确构建其他路径
        if cur.right:  # 右，判断当前节点是否有右子节点
            self.traversal(cur.right, path, result) # 递归调用traversal方法继续遍历右子树
            path.pop()  # 回溯，将当前节点从path列表中移除，完成右子树的遍历后，回到父节点继续处理其他可能的路径

时间复杂度为 O(n)，空间复杂度为 O(n) 

404.左叶子之和

思路：

题目中其实没有说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

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

使用递归法，递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

代码：

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        return self.dfs(root)
        
    def dfs(self,root):
        if root is None: # 如果当前节点root是None，即已经遍历到了叶子节点的下一层（空），则返回0
            return 0

        # 对左子树和右子树进行递归调用，并将返回的结果分别存储在leftValue和rightValue中
        leftValue = self.dfs(root.left)  # 左   
        rightValue = self.dfs(root.right)  # 右

        if root.left and not root.left.left and not root.left.right:  # 这里检查当前节点的左子节点是否存在，并且其左子节点和右子节点都不存在（即它是一个叶子节点）。如果满足这些条件，当前节点的左子节点就为左叶子节点，将当前节点左叶子节点的值赋给leftValue
            leftValue = root.left.val
            
        sum_val = leftValue + rightValue  # 中，将左子树和右子树的结果相加，得到当前节点的所有子树中左叶子节点值的总和，并返回这个值
        return sum_val

时间复杂度为 O(n)

空间复杂度为 O(n)