day15 110.平衡二叉树 257.二叉树的所有路径 404.左叶子之和 222.完全二叉树的节点个数

redohealer

已于 2024-09-26 10:20:31 修改

阅读量311

点赞数 3

文章标签：数据结构

于 2024-09-26 10:19:56 首次发布

本文链接：https://blog.csdn.net/2301_79240694/article/details/142548850

版权

110. 平衡二叉树

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

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

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

110.平衡二叉树

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

110.平衡二叉树1

返回 false 。

第一种方法（递归法-后序遍历）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        
        def getHeight(node):
            if not node:
                return 0
            leftHeight = getHeight(node.left)
            if leftHeight == -1:
                return -1
            rightHeight = getHeight(node.right)
            if rightHeight == -1:
                return -1
            if abs(leftHeight - rightHeight) > 1:
                return -1
            else:
                return 1 + max(leftHeight, rightHeight)
        

        result = getHeight(root)

        return False if result == -1 else True

257. 二叉树的所有路径

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

说明: 叶子节点是指没有子节点的节点。

示例:

257.二叉树的所有路径1

第一种方法（递归法-前序遍历）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:

        result = []
        path = []

        def getPath(node, path, result):
            if node:
                path.append(str(node.val))

                if not node.left and not node.right:
                    result.append('->'.join(path))

                getPath(node.left, path, result)
                getPath(node.right, path, result)
                path.pop()

        getPath(root, path, result)
        return result

404. 左叶子之和

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

示例：

404.左叶子之和1

第一种方法（递归法-后序遍历）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:

        def traversal(node):
            if not node:
                return 0
            if not node.left and not node.right:
                return 0
                
            leftNum = traversal(node.left)
            if node.left and not node.left.left and not node.left.right:
                leftNum = node.left.val
                
            rightNum = traversal(node.right)
                
            return leftNum +rightNum
        
        return traversal(root)

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

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

示例 1：

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

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

提示：

树中节点的数目范围是[0, 5 * 10^4]
0 <= Node.val <= 5 * 10^4
题目数据保证输入的树是完全二叉树

第一种方法（递归法-后序遍历-利用满二叉树特性优化）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:    
        
        # 确定终止条件：节点为空的情况
        if not root:
            return 0
        # 确定终止条件：利用满二叉树特性
        left = root.left
        right = root.right
        leftdepth, rightdepth = 1, 1
        while left:
            left = left.left
            leftdepth += 1
        while right:
            right = right.right
            rightdepth += 1
        if leftdepth == rightdepth: 
            return 2 ** leftdepth - 1
        # 确定单层递归的逻辑        
        leftNum = self.countNodes(root.left) 
        rightNum = self.countNodes(root.right)    
        
        return leftNum + rightNum + 1