算法基础之二叉树相关实战（下）（Leetcode题型归纳）

最新推荐文章于 2024-05-09 18:10:33 发布
最新推荐文章于 2024-05-09 18:10:33 发布
阅读量4.1k 收藏
点赞数
分类专栏： 算法基础 文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Buluchacha/article/details/121999397
版权

算法基础之二叉树相关实战

3.路径和相关题目

3.1介绍

在这里插入图片描述

3.2真题分析

3.2.1路径总和（112）

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode 112 方法1
class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if root == None:
            return False

        # 当前节点是叶子，检查 root.val 值是否为 sum
        if root.left == None and root.right == None and root.val == sum:
            return True

        # 当前节点不是叶子，对它的所有孩子节点，递归调用 hasPathSum() 函数
        return self.hasPathSum(root.left,sum-root.val) or self.hasPathSum(root.right,sum-root.val)

在这里插入图片描述

#leetcode 112 方法2
class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if root == None:
            return False

        stack = [(root,sum)]
        while stack:
            node,sum = stack.pop()
            # 判断叶子节点是否满足了条件
            if node.left == None and node.right == None and node.val == sum:
                return True
            
            # 左节点不为空，我们把左节点和剩余值打包压栈
            if node.left != None:
                stack.append((node.left,sum-node.val))
            # 右节点不为空，我们把右节点和剩余值打包压栈
            if node.right != None:
                stack.append((node.right,sum-node.val))

        return False

3.2.2路径总和2（113）

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode113 方法1
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        # 辅助函数（因为需要一个变量记录路径）       
        def helper(root, sum, temp):
            if root == None:
                return

            # 路径和满足sum，路径添加到结果数组res
            if root.left == None and root.right == None and root.val == sum:
                temp += [root.val]
                res.append(temp)

            # 递归搜索左右子树，传入剩余和以及路径
            helper(root.left,sum-root.val,temp+[root.val])
            helper(root.right,sum-root.val,temp+[root.val])


        res = []
        helper(root,sum,[])

        return res

#leetcode113 方法2
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        if root == None:
            return []

        res = []
        temp = []
        stack = [(root,sum,temp)]

        while stack:
            node,sum,temp = stack.pop()
            # 判断叶子节点是否满足了条件
            if node.left == None and node.right == None and node.val == sum:
                temp += [node.val]
                res.append(temp)

            if node.left != None:
                stack.append((node.left,sum-node.val,temp + [node.val]))

            if node.right != None:
                stack.append((node.right,sum-node.val,temp + [node.val]))

        return res

3.2.3二叉树中的最大路径和（124）

在这里插入图片描述

在这里插入图片描述

3.2.4求根到叶子节点数字之和（129）

在这里插入图片描述
在这里插入图片描述

#leetcode129 递归
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        def helper(root, nums):
            if root == None:
                return 0

            # 更新路径和
            nums *= 10
            nums += root.val

            # 如果已经是叶子节点，保存路径和到列表中
            if root.left == None and root.right == None:
                res.append(nums)

            if root.left != None:
                helper(root.left,nums)

            if root.right != None:
                helper(root.right,nums)

        
        res = []
        helper(root,0)

        return sum(res)

#leetcode129 迭代
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        if root == None:
            return 0

        stack = [(root,0)]
        res = []

        while stack:
            node,nums = stack.pop()
            # 更新路径和
            nums *= 10
            nums += node.val

            # 如果已经是叶子节点，保存路径和到列表中
            if node.left == None and node.right == None:
                res.append(nums)

            if node.left != None:
                stack.append((node.left,nums))

            if node.right != None:
                stack.append((node.right,nums))

        return sum(res)

3.2.5 二叉树中的最大路径和（124）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#leetcode 124
class Solution:
    def __init__(self):
        self.maxSum = float("-inf")

    def maxPathSum(self, root: TreeNode) -> int:
        def maxGain(node):
            if not node:
                return 0

            # 递归计算左右子节点的最大贡献值
            # 只有在最大贡献值大于 0 时，才会选取对应子节点
            leftGain = max(maxGain(node.left), 0)
            rightGain = max(maxGain(node.right), 0)
            
            # 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
            priceNewpath = node.val + leftGain + rightGain
            
            # 更新答案
            self.maxSum = max(self.maxSum, priceNewpath)
        
            # 返回节点的最大贡献值
            return node.val + max(leftGain, rightGain)
   
        maxGain(root)
        return self.maxSum

3.2.6 二叉树的所有路径（257）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode257
class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        if root == None:
            return None

        res = []
        queue = [(root,'')]

        while queue:
            temp = ''
            length = len(queue)

            for _ in range(length):
                node,temp = queue.pop(0)
                temp += str(node.val)

                # 如果是叶子节点，记录路径
                if node.left == None and node.right == None:    
                    res.append(temp)

                # 格式要求
                temp += '->'

                if node.left != None:
                    queue.append((node.left,temp))

                if node.right != None:
                    queue.append((node.right,temp))

        return res

4.二叉树的构建相关题目

4.1介绍

在这里插入图片描述

4.2真题分析

4.2.1从前序与中序遍历序列构造二叉树（105）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode 105
class Solution(object):
	def buildTree(self, preorder, inorder):
		if not (preorder and inorder):
			return None
		# 根据前序数组的第一个元素，就可以确定根节点	
		root = TreeNode(preorder[0])
		# 用preorder[0]去中序数组中查找对应的元素
		mid_idx = inorder.index(preorder[0])
		# 递归的处理前序数组的左边部分和中序数组的左边部分
		# 递归处理前序数组右边部分和中序数组右边部分
		root.left = self.buildTree(preorder[1:mid_idx+1],inorder[:mid_idx])
		root.right = self.buildTree(preorder[mid_idx+1:],inorder[mid_idx+1:])
		return root

4.2.2从中序与后续遍历序列构造二叉树（106）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode106
class Solution(object):
    def buildTree(self, inorder, postorder):
        if not (inorder and postorder):
            return None
        # 将中序数组的下标、值保存到map中省去解法一中线性查找
        d = {val:idx for idx,val in enumerate(inorder)}
        self.post_idx = len(postorder)-1
        def dfs(left,right):
            if left>right:
                return None
            # 从后序数组中拿最后一个元素，根据这个元素去map中找到中序数组对应的index
            # 然后递归的处理右边[index+1,right]，递归处理左边[left,index-1]
            val = postorder[self.post_idx]
            self.post_idx -= 1
            root = TreeNode(val)
            index = d[val]
            root.right = dfs(index+1,right)
            root.left = dfs(left,index-1)
            return root
        return dfs(0,len(inorder)-1)

4.2.3根据前序和后续遍历构造二叉树（889）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#leetcode 889
class Solution(object):
    def constructFromPrePost(self, pre, post):
        def dfs(pre,post):
            if not pre:
                return None
            # 数组长度为1时，直接返回即可
            if len(pre)==1:
                return TreeNode(pre[0])
            # 根据前序数组的第一个元素，创建根节点     
            root = TreeNode(pre[0])
            # 根据前序数组第二个元素，确定后序数组左子树范围
            left_count = post.index(pre[1])+1
            # 递归执行前序数组左边、后序数组左边
            root.left = dfs(pre[1:left_count+1],post[:left_count])
            # 递归执行前序数组右边、后序数组右边
            root.right = dfs(pre[left_count+1:],post[left_count:-1])
            # 返回根节点
            return root
        return dfs(pre,post)
孤岛使者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【leetcode】二叉树常考题型总结
zhaohb2016的博客
08-21 183
对于二叉树的题型，多出在面试中，笔试相对较少，要多总结做到心中有数。尽量做到递归和迭代都熟悉。
LeetCode 数据结构与算法（永久分享）
03-27
LeetCode经典题型-代码+课件+视频，下载链接 包含了栈，队列，堆；动态规划；二分查找与二分查找树；哈希表与字符串；贪心算法；高级数据结构；递归，回溯与分治；二叉树与图；链表
算法基础之二叉树相关实战（上）（Leetcode题型归纳）
Buluchacha的博客
12-17 1008
算法基础之二叉树相关实战（Leetcode题型归纳）1.二叉树的性质相关题目1.1介绍1.2真题分析1.2.1相同的树（100）1.2.2对称二叉树（101）1.2.3平衡二叉树（110）1.2.4二叉树的最大深度（104）1.2.5二叉树的最小深度（111）1.2.6二叉树最大宽度（662）2.二叉树的遍历相关题目2.1介绍2.2真题分析（深度优先搜索）2.2.1二叉树的前序遍历（144）2.2.2二叉树的中序遍历（94）2.2.3二叉树的后序遍历（145）2.3真题分析（广度优先搜索）2.3.1二叉树的
LeetCode算法之--二叉树系列
程序大视界
12-21 352
二叉树的常见算法
LeetCode算法---题型总纲之基础算法
SOLar7SysteM的博客
03-17 410
LeetCode算法—题型总纲之基础算法 基础算法 标题枚举 线性枚举 多维枚举 前缀和 双指针 尺取法（滑动窗口） 链表快慢指针 分而治之 二分查找 点分治 树分治 标题排序 排序算法 比较排序入门 冒泡排序 简单插入排序 简单选择排序 比较排序进阶 归并排序 希尔排序 快速排序 非比较排序 桶排序 计数排序 基数排序 排序API使用 多关键字排序 字典序 结构体排序 标题贪心 区间选择问题 分配问题 贪心背包 区间问题 最小生成树 Prim
算法题型：二叉树（leetcode+剑指offer）
IMUHERO
08-01 848
目录 一、111. 二叉树的最小深度 二、100. 相同的树 三、101. 对称二叉树 四、110. 平衡二叉树 五、剑指offer（24）二叉树中和为某一值的路径 六、剑指offer（三十八）计算二叉树的最大深度 七、剑指offer（五十六）二叉树的下一个节点 八、剑指offer（五十八）按照Z型打印二叉树 九、剑指offer（五十九）层序遍历二叉树（改进版，需存进双层链表中...
leetcode总结-二叉树题型总结
abcnull 的博客
05-12 500
文章目录前言题型关键词算法步骤 前言 在我们做二叉树的基础算法题目的时候一定需要异常熟练的掌握以下知识点，这样写二叉树的题目才能游刃有余 写二叉树前必须非常熟练的掌握如下： 先中后序遍历递归与非递归 二叉树的先中后序遍历的递归与非递归写法，必须非常熟练的写，并且非递归写法有常见的两种写法（一种是严蔚敏版的一种是先存入一个结点到栈中，然后每次循环把该结点在直接孩子结点全部入栈），必须非常熟练的掌握 层次遍历的队列写法 二叉树的层次遍历的写法（用队列实现），必须非常熟练的写，并且要非常熟练的写两种，一种
递归算法——Leetcode题型总结（1）
ALISAlwz的博客
06-04 346
二叉树专题 目录1，最长同值路径（Leetcode 687 题）1.1 二叉树的直径（543题）2，BiNode3，二叉搜索树的范围和（938）4，二叉搜索树节点最小距离（783） 1，最长同值路径（Leetcode 687 题） 题目描述：给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。 注意：两个节点之间的路径长度由它们之间的边数表示。 示例 1: 输入: 5 / \ 4 5 /
leetCode题型总结
逆流而上Mr李
08-25 2960
本文选取了LeetCode和剑指offer中的经典面试题，供大家进行参考 LeetCode leetcode 总计176道题，下面根据对应目录一一对应。 二分查找 位运算 分治算法 动态规划 双指针 哈希表 图 字符串 排序 搜索 数学 数组+矩阵 栈和队列 树 贪心算法 链表 一、二分查找 * [1. X的平方差](#1-求开方) * [2. ...
二叉树算法题汇总
热门推荐
一念永恒
05-19 1万+
目录 二叉树的遍历 前序遍历 中序遍历 后序遍历 层次遍历 基础算法 求二叉树中的节点个数 求二叉树的深度（高度） 求二叉树第k层的节点个数 求二叉树中叶子节点的个数 判断两棵二叉树是否相同的树 判断二叉树是不是平衡二叉树 求二叉树的镜像 判断两个二叉树是否互相镜像 判断是否为二分查找树BST 本文的实例代码基于JAVA编写 首先给出节点的数据结构 publi...
leetcode中国-Algorithm:算法解题思路及总结
06-29
做算法题难度要循序渐进，如果本身有基础，熟练度高，那么做leetcode的简单题型应该是几分钟一题；如果简单的都花费很长时间，说明熟练度不够，更应该从简单的开始，然后过度到中等，再到困难。目前国内大厂的算法...
leetcode中文版-leetcode:算法笔记总结。包括《剑指offer》《程序员笔试面试指南》《Leetcode》相关题目
06-29
leetcode中文版 算法笔记 介绍： 本项目是算法学习过程中的代码部分。目前分为四个模块： 第一部分：《剑指offer》题解，共67道题已完结。 第二部分：《LeetCode》题解，更新中。 第三部分：《程序员笔试面试指南》...
vscode安装leetcode-beat-algorithm:学习算法，打败算法！
07-07
vscode安装leetcode 在工作中会发现算法其实无处不在，好好学习，总结出自己的知识体系。 目标 持之以恒，熟悉及掌握以下数据结构： 数组 链表 栈 队列 散列表 二叉树 学习以下算法及解题方案： 二分法 递归与分治 ...
leetcode-[removed]前攻城狮从零入门算法的宝藏题库，根据算法大师的经验总结了100+道LeetCode力扣的经典题型JavaScript题解和思路。一起加油
03-20
欢迎使用leetcode-[removed]waving_hand: 力扣的题解记录（JavaScript） 调试 提供了.vscode配置文件，在vscode中选择“小爬虫”图标，点击启动程序，即可启动断点调试。 思路 思路会记录在本仓库的问题，按标签进行...
[Easy] leetcode-35 搜索插入位置
最新发布
Sofine
05-09 118
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
实习面试之算法准备：数学题
lihao1875699404的博客
05-02 1035
这不难得出，第 1 轮会被按，第 2 轮，第 3 轮，第 6 轮都会被按。dp[i][j] 表示当剩下的石子堆为下标 i到下标 j时，即在下标范围 [i,j] 中，在双方都做最好选择的情况下，先手与后手的最大得分差值为多少。这样一直循环下去，我们发现只要踩到 4 的倍数，就落入了圈套，永远逃不出 4 的倍数，而且一定会输。盏灯的开关，有的被关闭，比如 3，有的被打开，比如 6）…显然，如果对手拿的时候只剩 4 颗石子，那么无论他怎么拿，总会剩下 1~3 颗石子，我就能赢。第一轮，你将会打开所有灯泡。
C语言 | Leetcode C语言题解之第73题矩阵置零
m0_59237910的博客
05-07 279
C语言 | Leetcode C语言题解之第73题矩阵置零
LeetCode 35.搜索插入位置
tus00000的博客
05-08 192
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。此算法时间复杂度为O(logn)，空间复杂度为O(1)。请必须使用时间复杂度为 O(log n) 的算法。nums 为 无重复元素 的 升序 排列数组。
leetcode 二叉树
09-16
在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值