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

那一抹阳光多灿烂2024-07-31 16:58

代码随想录训练营 Day15打卡 二叉树 part03

一、 力扣110. 平衡二叉树

给定一个二叉树，判断它是否是 平衡二叉树
示例 ：

输入 ：root = [3,9,20,null,null,15,7]
输出：true

这里强调一波概念：

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。

二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：

思路与递归分析

给定一个二叉树，判断它是否是平衡二叉树。平衡二叉树定义为每个节点的左右子树高度差不超过1。

递归三步曲分析

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

    参数：当前传入节点。

    返回值：以当前传入节点为根节点的树的高度。如果已经不是平衡树，返回-1。

  2. 明确终止条件：

    当节点为空时，返回高度0。

  3. 明确单层递归的逻辑：

    分别求出左右子树的高度。

    如果左右子树的高度差大于1，返回-1。

    否则，返回当前树的高度（即左右子树高度的最大值加1）。

代码实现

版本一 递归法

python 复制代码 
# 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: TreeNode) -> bool:
        # 调用 get_height 函数，如果返回值不是 -1，说明是平衡二叉树
        return self.get_height(root) != -1

    def get_height(self, root: TreeNode) -> int:
        # 基本情况：如果节点为空，返回高度 0
        if not root:
            return 0

        # 递归求左子树高度
        left_height = self.get_height(root.left)
        # 如果左子树已经不是平衡树，直接返回 -1
        if left_height == -1:
            return -1

        # 递归求右子树高度
        right_height = self.get_height(root.right)
        # 如果右子树已经不是平衡树，直接返回 -1
        if right_height == -1:
            return -1

        # 当前节点：判断左右子树高度差是否超过 1
        if abs(left_height - right_height) > 1:
            return -1
        else:
            # 如果高度差在允许范围内，返回当前树的高度
            return 1 + max(left_height, right_height)

版本二 递归法 精简版

python 复制代码 
# 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:
        # 调用 get_height 函数，如果返回值不是 -1，说明是平衡二叉树
        return self.get_height(root) != -1

    def get_height(self, node: TreeNode) -> int:
        # 基本情况：如果节点为空，返回高度 0
        if not node:
            return 0

        # 递归求左子树高度
        left = self.get_height(node.left)
        # 递归求右子树高度
        right = self.get_height(node.right)

        # 判断左右子树高度差是否超过 1 或者左右子树已经不是平衡树
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        
        # 返回当前树的高度
        return max(left, right) + 1

力扣题目链接
题目文章讲解
题目视频讲解

二、 力扣257. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。
示例 ：

输入 ：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

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

递归法

递归解法是比较直观和常见的做法，可以按照前序遍历（根左右）的顺序进行处理。

  1. 定义递归函数 traversal(cur, path, result)：

    cur 是当前节点。

    path 是从根节点到当前节点的路径。

    result 是存放所有路径的结果列表。

  2. 递归终止条件：

    如果当前节点是叶子节点（即没有左右子节点），将路径转换成字符串格式并加入结果列表。

  3. 递归过程：

    将当前节点的值加入到路径中。

    递归处理左子树和右子树。

    递归完成后，需要进行回溯，即将当前节点从路径中删除，以便处理其他路径。

  4. 边界处理：

    如果根节点为空，则直接返回空列表。

python 复制代码 
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

迭代法

迭代解法使用栈来模拟递归的过程，也是按照前序遍历的顺序处理节点。

  1. 使用两个栈 stack 和 path_st 来分别存放当前节点和对应的路径

stack 存放当前处理的节点。

path_st 存放从根节点到当前节点的路径字符串。

  1. 使用循环遍历栈，直到栈为空

弹出当前节点和对应的路径。

如果当前节点是叶子节点，将路径添加到结果列表中。

将右子节点和左子节点（先右后左，保证前序遍历顺序）依次入栈，并更新路径字符串。

  1. 最终返回结果列表。
python 复制代码 
class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        if not root:
            return []  # 如果根节点为空，返回空列表
        stack, path_st, result = [root], [str(root.val)], []  # 初始化栈、路径栈和结果列表

        while stack:
            cur = stack.pop()  # 弹出当前处理的节点
            path = path_st.pop()  # 弹出当前路径
            # 如果当前节点为叶子节点
            if not (cur.left or cur.right):
                result.append(path)  # 将完整路径添加到结果列表中
            # 如果当前节点有右子节点
            if cur.right:
                stack.append(cur.right)  # 将右子节点压入栈中
                path_st.append(path + '->' + str(cur.right.val))  # 更新路径，将新路径压入路径栈中
            # 如果当前节点有左子节点
            if cur.left:
                stack.append(cur.left)  # 将左子节点压入栈中
                path_st.append(path + '->' + str(cur.left.val))  # 更新路径，将新路径压入路径栈中

        return result

力扣题目链接
题目文章讲解
题目视频讲解

三、 力扣404. 左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。
示例：

输入: root = [3,9,20,null,null,15,7]
输出: 24
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

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

相信通过这两个图，大家对最左叶子的定义有明确理解了。

版本一 递归法（后序遍历）

实现思路：通过后序遍历递归方法来累加左叶子的数值。此方法中，左子树的递归结果可能需要重新赋值，确保只有左叶子的值被累加。

python 复制代码 
class Solution:
    def sumOfLeftLeaves(self, root):
        if root is None:
            return 0  # 如果节点为空，返回0
        if root.left is None and root.right is None:
            return 0  # 如果是叶子节点，返回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

版本二 递归法（精简版）

实现思路：这个版本在每一层递归中同时检查并累加左叶子节点的值，并递归处理左右子树。此方法减少了递归的调用层级，提高了效率。

python 复制代码 
class Solution:
    def sumOfLeftLeaves(self, root):
        if root is None:
            return 0  # 如果节点为空，返回0
        leftValue = 0
        if root.left 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)

版本三 迭代法

实现思路：使用栈来模拟递归过程，对每个节点进行检查，如果左子节点是叶子节点，则累加其值。此迭代方法有效地避免了递归可能导致的栈溢出问题，适合处理深度较大的树。

python 复制代码 
class Solution:
    def sumOfLeftLeaves(self, root):
        if root is None:
            return 0  # 如果根节点为空，返回0
        st = [root]  # 使用栈来进行迭代
        result = 0  # 初始化左叶子节点之和为0
        while st:
            node = st.pop()  # 弹出节点进行处理
            if node.left and node.left.left is None and node.left.right is None:
                # 如果左子节点存在且为叶子节点，则累加其值
                result += node.left.val
            if node.right:
                st.append(node.right)  # 如果右子节点存在，添加到栈中
            if node.left:
                st.append(node.left)  # 如果左子节点存在，添加到栈中
        return result

力扣题目链接
题目文章讲解
题目视频讲解

四、 力扣222. 完全二叉树的节点个数

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
示例 ：

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

大家要自己看完全二叉树的定义，很多同学对完全二叉树其实不是真正的懂了。

我来举一个典型的例子如题：

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

版本一

实现思路：该方法首先通过迭代计算左右子树的最大深度，如果深度相等，则树是满二叉树，可以直接使用公式计算节点总数。如果不是满二叉树，则递归计算左右子树的节点数，并加上根节点。

python 复制代码 
class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0  # 如果根节点为空，则节点总数为0
        left = root.left  # 左子树的根节点
        right = root.right  # 右子树的根节点
        leftDepth = 0  # 左子树的深度初始化为0
        rightDepth = 0  # 右子树的深度初始化为0
        while left:  # 计算左子树的最大深度
            left = left.left
            leftDepth += 1
        while right:  # 计算右子树的最大深度
            right = right.right
            rightDepth += 1
        if leftDepth == rightDepth:
            return (2 << leftDepth) - 1  # 如果左右子树深度相等，则是满二叉树
        return self.countNodes(root.left) + self.countNodes(root.right) + 1

版本二

实现思路：这个版本使用了层级计数的方式来检测是否是满二叉树。如果在某一层中同时存在左右子节点，且都到达底部（同时为空），则通过公式计算。否则，递归地计算左右子树的节点数。

python 复制代码 
class Solution: 
    def countNodes(self, root: TreeNode) -> int:
        if not root: 
            return 0  # 如果根节点为空，则节点总数为0
        count = 1  # 计数包含根节点
        left = root.left; right = root.right
        while left and right:  # 计算同时有左右子节点的层次
            count += 1
            left = left.left; right = right.right
        if not left and not right:  # 如果左右子树同时为空，则到达了满二叉树的最底部
            return 2**count - 1  # 使用公式计算满二叉树的节点数
        return 1 + self.countNodes(root.left) + self.countNodes(root.right)  # 递归计算左右子树节点数加根节点

力扣题目链接
题目文章讲解
题目视频讲解

相关推荐
2401_840192279 分钟前
如何学习一门计算机技术
开发语言·git·python·devops
奋进的小暄9 分钟前
贪心算法（15）（java）用最小的箭引爆气球
算法·贪心算法
Scc_hy21 分钟前
强化学习_Paper_1988_Learning to predict by the methods of temporal differences
人工智能·深度学习·算法
巷北夜未央23 分钟前
Python每日一题(14)
开发语言·python·算法
javaisC25 分钟前
c语言数据结构--------拓扑排序和逆拓扑排序(Kahn算法和DFS算法实现)
c语言·算法·深度优先
爱爬山的老虎25 分钟前
【面试经典150题】LeetCode121·买卖股票最佳时机
数据结构·算法·leetcode·面试·职场和发展
SWHL26 分钟前
rapidocr 2.x系列正式发布
算法
大模型真好玩26 分钟前
理论+代码一文带你深入浅出MCP：人工智能大模型与外部世界交互的革命性突破
人工智能·python·mcp
雾月551 小时前
LeetCode 914 卡牌分组
java·开发语言·算法·leetcode·职场和发展
想跑步的小弱鸡1 小时前
Leetcode hot 100(day 4)
算法·leetcode·职场和发展
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04RAG 实践- Ollama+RagFlow 部署本地知识库05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07如何本地部署AI智能体平台，带你手搓一个AI Agent08苍穹外卖面试总结09DeepSeek RAGFlow构建本地知识库系统10【芯片封测学习专栏 -- D2D 和 C2C 之间的区别】