代码随想录算法训练营Day15 | 二叉树 110.平衡二叉树 257.二叉树的所有路径 404.左叶子之和 222.完全二叉树的节点个数

110.平衡二叉树

题目：110.平衡二叉树

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

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

# 什么是高度？什么是深度？

  返回 True    返回 False

方法：

① 递归法

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if self.get_height(root) != -1:
            return True
        else:
            return False

    def get_height(self, root: TreeNode) -> int:
        # Base Case
        if not root:
            return 0
        # 左
        if (left_height := self.get_height(root.left)) == -1:
            return -1
        # 右
        if (right_height := self.get_height(root.right)) == -1:
            return -1
        # 中
        if abs(left_height - right_height) > 1:
            return -1
        else:
            return 1 + max(left_height, right_height)

② 递归法 （精简版）

def 是否平衡，接受一个参数root，返回bool是或否

def get_hight 当前树节点，若为空，则返回0；计算当前节点的左、右子树的高度；若高度是-1 或高度差绝对值大于1，都为不平衡。

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.get_hight(root) != -1
    def get_hight(self, node):
        if not node:
            return 0
        left = self.get_hight(node.left)
        right = self.get_hight(node.right)
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        return max(left, right) + 1

二叉树节点的深度&高度概念区分

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。（从上到下）
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。（从下到上）

   

257.二叉树的所有路径

题目：257.二叉树的所有路径

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

 

 python：

递归法 + 回溯

traversal 递归函数，遍历二叉树。cur当前结点，path是当前路径，result存储所有路径列表。

如果当前结点有左子结点，调用遍历左子树，回溯，从路径列表移除最后一个元素；

如果当前结点有右子结点，调用遍历左子树，回溯，从路径列表移除最后一个元素；

binaryTreePaths(self, root)，它接受二叉树根节点root作为参数；调用traversal方法，从根节点开始遍历二叉树。

class Solution:
    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()  # 回溯

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

 404.左叶子之和

题目：404.左叶子之和

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

首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。 

方法：

递归法

class Solution:
    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

递归法（精简） 

先检查根节点左子结点是否存在，且这个左子结点没有左子结点和右子结点。

class Solution:
    def sumOfLeftLeaves(self, root):
        if root is None:
            return 0
        leftValue = 0
        if root.left is not None and root.left.left is None and root.left.right is None:
            leftValue = root.left.val
        return leftValue + self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)

222.完全二叉树的节点个数

 题目：222. 完全二叉树的节点个数

给出一个完全二叉树，求出该树的节点个数。

示例 1：

• 输入：root = [1,2,3,4,5,6]
• 输出：6

python方法；

① 递归法

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        return self.getNodesNum(root)
        
    def getNodesNum(self, cur):
        if not cur:
            return 0
        leftNum = self.getNodesNum(cur.left) #左
        rightNum = self.getNodesNum(cur.right) #右
        treeNum = leftNum + rightNum + 1 #中
        return treeNum

 ② 递归法（精简）

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1 + self.countNodes(root.left) + self.countNodes(root.right)