代码随想录算法训练营 DAY 23 | 450.删除二叉搜索树中的节点 669.修剪二叉搜索树 538.把二叉搜索树转换为累加树

最新推荐文章于 2025-05-28 10:48:32 发布
最新推荐文章于 2025-05-28 10:48:32 发布
阅读量740 收藏 18
点赞数 19
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35904005/article/details/137124861
版权
文章详细讲解了如何修剪二叉搜索树，包括递归删除节点并更新边界的过程，以及二叉搜索树的构造、搜索、插入、删除和公共祖先问题的解决策略，强调了递归和迭代在这些问题中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

669.修剪二叉搜索树

  • 误区：节点不在范围内不能直接return null，因为它的右子树是可能符合边界的。虽然要删除这个节点，但还要先继续遍历右子树。

递归套递归，删除修剪的同时去递归修剪左/右子树，然后在下面递归左右子树的时候用root.left right接住

  1. 确定递归函数 传入新的左右边界，返回新的根节点
TreeNode trimBST(TreeNode root, int low, int high)
  1. 终止条件
if(root == null) return null;
  1. 单层递归逻辑

如果一个节点在边界左侧，还要往右遍历。它的返回值是这棵右子树修剪完后的根节点。

不能直接return right！因为右子树不一定完全符合边界，要递归处理。

if(root.val < low) {
    right = traversal(root.right,low,high); //返回值要在上一层接住
    return right;  //一会在上一层的左子树接住
}
if(root.val > high) {  //在边界右侧的情况同理
    left = traversal(root.left,low,high);
    return left;   //一会在上一层的右子树接住
}
root.left = traversal(root.left,low,high);
root.right = traversal(root.right,low,high);
return root;
  • 完整代码
class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root == null) return null;
        if(root.val < low ) {
            TreeNode right = trimBST(root.right,low,high);
            return right;
        }
        if(root.val > high) {
            TreeNode left = trimBST(root.left,low,high);
            return left;
        }
        root.left = trimBST(root.left,low,high);
        root.right = trimBST(root.right,low,high);
        return root;
    }
}

这一题和上一题都是在递归的推出条件上做的文章, 遍历顺序倒无所谓

108.将有序数组转换为二叉搜索树

  • 注意 要构造一棵平衡二叉搜索树

大致思路：每一次都选择中间的节点，将这个数组分为左区间和右区间，递归遍历左区间构造左子树，遍历右区间构造右子树。

长度为偶数怎么办呢？—取左侧或者右侧的都可以

每次进入递归的时候new出来节点赋值，把它return回去 递归的时候用root.left/right接住它

注意区间的定义：保持左闭右闭！

  1. 确定递归函数
TreeNode traversal(int[] nums, left, right)

  1. 确定终止条件（什么时候是非法的区间？停止构造）

    当left = right的时候，区间是合法的。

if(left > right) return null;  //此时才是非法区间
  1. 单层递归逻辑
int mid = (left + right)/2;
TreeNode root = new TreeNode(nums[mid]); //构造根节点
//接下来递归构造左右子树
root.left = traversal(nums,left,mid-1);
root.right = traversal(nums,mid+1,right);
return root;
  • 调用递归函数
return traversal(nums,0,nums.length-1);

class Solution {
    public TreeNode traversal(int[] nums, int left, int right) {
        if(left > right) return null;
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = traversal(nums, left, mid-1); //更新右边界
        root.right = traversal(nums, mid+1, right);
        return root;
    }

    public TreeNode sortedArrayToBST(int[] nums) {
        return traversal(nums,0,nums.length-1);
    }
}

538.把二叉搜索树转换为累加树

  • 思路：如果给一个有序数组，变成累加数组！就是从后往前遍历，逐个累加前面节点的数值。

二叉搜索树的中序遍历（左中右）就是一个有序（升序）数组！

如何倒序遍历呢？右中左！数组的话用双指针实现，二叉树这里也可以用双指针！pre初始化为0

class Solution {
    TreeNode pre = null;
    //右中左 遍历
    public void traversal(TreeNode cur) {
        if(cur == null) return;
        traversal(cur.right);
        if(pre != null) {  //pre不为null才相加
            cur.val = pre.val + cur.val;
        }
        pre = cur;
        traversal(cur.left);
    }

    public TreeNode convertBST(TreeNode root) {
        traversal(root);
        return root;
    }
}

二叉树总结篇

遍历方式

  • 深度优先

    • [二叉树：前中后序递归法：递归三部曲初次亮相
    • [二叉树：前中后序迭代法（一） ：通过栈模拟递归
    • [二叉树：前中后序迭代法（二）统一风格]

  • 广度优先

    • [二叉树的层序遍历]：通过队列模拟

求二叉树的属性

  • 二叉树：是否对称
    • 递归：后序，比较的是根节点的左子树与右子树是不是相互翻转
    • 迭代：使用队列/栈将两个节点顺序放入容器中进行比较
  • 二叉树：求最大深度
    • 递归：后序，求根节点最大高度就是最大深度，通过递归函数的返回值做计算树的高度
    • 迭代：层序遍历
  • 二叉树：求最小深度
    • 递归：后序，求根节点最小高度就是最小深度，注意最小深度的定义
    • 迭代：层序遍历
  • 二叉树：求有多少个节点
    • 递归：后序，通过递归函数的返回值计算节点数量
    • 迭代：层序遍历
  • 二叉树：是否平衡
    • 递归：后序，注意后序求高度和前序求深度，递归过程判断高度差
    • 迭代：效率很低，不推荐
  • 二叉树：找所有路径
    • 递归：前序，方便让父节点指向子节点，涉及回溯处理根节点到叶子的所有路径
    • 迭代：一个栈模拟递归，一个栈来存放对应的遍历路径
  • 二叉树：递归中如何隐藏着回溯
    • 详解[二叉树：找所有路径 中递归如何隐藏着回溯
  • 二叉树：求左叶子之和
    • 递归：后序，必须三层约束条件，才能判断是否是左叶子。
    • 迭代：直接模拟后序遍历
  • 二叉树：求左下角的值
    • 递归：顺序无所谓，优先左孩子搜索，同时找深度最大的叶子节点。
    • 迭代：层序遍历找最后一行最左边
  • 二叉树：求路径总和
    • 递归：顺序无所谓，递归函数返回值为bool类型是为了搜索一条边，没有返回值是搜索整棵树。
    • 迭代：栈里元素不仅要记录节点指针，还要记录从头结点到该节点的路径数值总和

二叉树的修改与构造

  • 翻转二叉树
    • 递归：前序，交换左右孩子
    • 迭代：直接模拟前序遍历
  • 构造二叉树
    • 递归：前序，重点在于找分割点，分左右区间构造
    • 迭代：比较复杂，意义不大
  • 构造最大的二叉树
    • 递归：前序，分割点为数组最大值，分左右区间构造
    • 迭代：比较复杂，意义不大
  • 合并两个二叉树
    • 递归：前序，同时操作两个树的节点，注意合并的规则
    • 迭代：使用队列，类似层序遍历

求二叉搜索树的属性

  • 二叉搜索树中的搜索
    • 递归：二叉搜索树的递归是有方向的
    • 迭代：因为有方向，所以迭代法很简单
  • 是不是二叉搜索树
    • 递归：中序，相当于变成了判断一个序列是不是递增的
    • 迭代：模拟中序，逻辑相同
  • 求二叉搜索树的最小绝对差
    • 递归：中序，双指针操作
    • 迭代：模拟中序，逻辑相同
  • 求二叉搜索树的众数
    • 递归：中序，清空结果集的技巧，遍历一遍便可求众数集合
    • [二叉搜索树转成累加树]
    • 递归：中序，双指针操作累加
    • 迭代：模拟中序，逻辑相同

二叉树公共祖先问题

  • 二叉树的公共祖先问题
    • 递归：后序，回溯，找到左子树出现目标值，右子树节点目标值的节点。
    • 迭代：不适合模拟回溯
  • 二叉搜索树的公共祖先问题
    • 递归：顺序无所谓，如果节点的数值在目标区间就是最近公共祖先
    • 迭代：按序遍历

二叉搜索树的修改与构造

  • 二叉搜索树中的插入操作
    • 递归：顺序无所谓，通过递归函数返回值添加节点
    • 迭代：按序遍历，需要记录插入父节点，这样才能做插入操作
  • 二叉搜索树中的删除操作
    • 递归：前序，想清楚删除非叶子节点的情况
    • 迭代：有序遍历，较复杂
  • 修剪二叉搜索树
    • 递归：前序，通过递归函数返回值删除节点
    • 迭代：有序遍历，较复杂
  • 构造二叉搜索树
    • 递归：前序，数组中间节点分割
    • 迭代：较复杂，通过三个队列来模拟

总结

  • 涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。
  • 求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。
  • 求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了
林酽
关注
代码随想录算法训练营day23|669.修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
weixin_43836337的博客
06-16 488
这道题目需要考虑当前节点是否在[low,high]之间，因为是平衡二叉树，所以当当前节点值小于low时，那么其左节点肯定更小，因此删除该节点的方式是给root节点返回其，注意：这里不是直接返回右节点，是因为在右子树中也有可能存在不满足条件的节点，需要继续递归排查；当当前节点值大于high时，那么其右节点肯定更大，因此删除该节点的方式是给root节点返回其。如果root.val符合在[low,high]的区间内，其左右节点承接左右节点的返回值即可。最终返回root。
代码随想录算法训练营Day18 | 669. 修剪二叉搜索树，108.将有序数组转换为二叉搜索树，538.把二叉搜索树转换为累加树
little__penguin的博客
06-30 230
代码随想录算法训练营day23 | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
weixin_69675605的博客
03-15 1044
LeetCode | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
代码随想录算法训练营day21|669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树
aaal1234的博客
11-20 185
这道题刚开始做的时候我以为思路和删除二叉搜索树中的节点的题目很像，但是听完卡哥的讲解后才发现这样的想法是不对的，因为删除二叉搜索树中的节点时，二叉搜索树中只有一个符合条件的元素，因此可以找到元素时立刻return。处理完找到所需节点时的逻辑后，再处理没找到所需节点时的逻辑，即root->left=trim(root->left,val),root->right=trim(root->right,val)。这题基本思路是先将二叉树排序，然后每次取数列中的中间的值作为二叉树的节点，然后递归即可。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
Harryline的博客
11-20 405
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
代码随想录算法训练营DAY23｜669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树、总结篇
Greeneril_的博客
05-30 242
涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。如果单纯求深度就用前序求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了。
代码随想录算法训练营Day21|669.修剪二叉搜索树、 108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
weixin_44426359的博客
08-21 216
当前节点如果小于左边界，则当前结点的左子树一定小于左边界，不再考虑。当前节点的右子树需要再修剪，修剪后的结果进行返回，代替当前节点的位置。思路：因为要转换成平衡二叉树，所以要先找到中间节点，再递归左右子树。思路：递归当前子树的左右子树去修剪。思路:右中左遍历，好像一个指针就够了。遍历到节点为空就返回。108.将有序数组转换为二叉搜索树。538.把二叉搜索树转换为累加树。
代码随想录训练营Day26 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
m0_68965961的博客
10-06 1051
给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。取哪一个都可以，只不过构成了不同的平衡二叉搜索树。节点的左子树仅包含键 小于 节点键的节点。节点的右子树仅包含键 大于 节点键的节点。改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。所以结果应当返回修剪好的二叉搜索树的新的根节点。通过修剪二叉搜索树，使得所有节点的值在。
代码随想录算法训练营Day23 | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树、二叉树总结 | Python | 个人记录向
Python基本算法
04-25 835
二叉树：669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树、二叉树总结。
【漫话机器学习系列】275.GrabCut 算法——用于去除图片背景（Grabcut For Removing Image Backgrounds）
IT古董
05-24 773
GrabCut 是由微软剑桥实验室于 2004 年提出的一种交互式图像前景分割算法。相比传统的图像分割方法，它的亮点是：支持用户轻松交互，只需简单画个矩形；基于高斯混合模型（GMM）与图割（Graph Cut）优化；分割效果细腻，适用于复杂背景下的图像处理。GrabCut 是一项结合图割与 GMM 的强大图像分割算法；通过手动圈定目标区域，就能自动判断前景与背景；适合中等难度的抠图任务，是 OpenCV 实战中的常用技能之一。
016搜索之广度优先BFS——算法备赛
2401_82484471的博客
05-27 668
广度优先搜索是一种逐层遍历的方式，是图论，树论的基本搜索方式，在决策类问题上也有应用。 算法的关键是准备一个`节点队列`，每遍历一个节点将其所有未访问的子节点(或所有的邻接节点)入队，遍历完一个节点后及时从队列中出队。当队列为空遍历结束。 BFS作为基础搜索算法，其逐层扩散的特点在很多高级算法有着广泛的应用，如`Djstra`算法就是用优先队列实现的`BFS`。
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖
m0_75262437的博客
05-27 1041
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖时间限制: 2s 内存限制: 192MB 提交: 415 解决: 105题目描述LQ 商场为了回馈广大用户，为在此消费的用户提供了抽奖机会：抽奖机有三个转轮，每个转轮上都分布有 n 个数字图案，标号为 1 ∼ n ，按照从 1 到 n 顺序转动，当转到第 n 个图案时会从第一个继续开始。奖项如下：1）三个相同的图案，积分 +200；2）两个相同的图案，积分 +100；
DeepSeek 赋能智能安防：从算法革新到场景落地的全解析
邓邓子的博客
05-27 849
随着人工智能技术的快速发展，智能安防系统迎来了新的变革机遇。本文聚焦 DeepSeek 在智能安防系统中的应用，深入剖析其基于 Transformer 架构与混合专家架构的核心技术原理。详细阐述 DeepSeek 在智能监控预警、门禁身份识别、智能分析决策及系统运维优化等场景中的实践应用，结合智慧社区、智慧监狱等实际案例，展现其高精度识别、高效决策优势。同时，客观分析DeepSeek应用过程中面临的数据安全、算法优化等挑战，并对其与物联网、大数据融合的未来发展方向进行展望，为智能安防领域技术创新提供参考。
java 代码查重（五）比较余弦算法、Jaccard相似度、欧式距离、编辑距离等在计算相似度的差异
我的E家
05-24 1261
为了实现更准确对比2个Java代码的相似度(用于Java课程作业查重场景)， 可以将Java源码原封不动保存到.java文件中，可以得到更准确结果，且不同相似度算法下计算的相似度差异一致。比较源文件和目标文件都是标准的Java代码(.java代码)，唯一区别在于目标文件含有注释，源文件没有注释。初步结论： 相同的Java代码复制到文本文件中(.txt文件)，不同算法检查的相似度差异较大。比较源文件和目标文件都是标准的Java代码，唯一区别在于目标文件含有注释，源文件没有注释。
【Halcon】图像分割中的 regiongrowing 与dyn_threshold 动态阈值 算法详解对比
最新发布
songhuangong123的博客
05-28 605
动态阈值通过比较当前像素与模糊背景图的灰度差异，实现前景/背景分离，适用于背景不均但结构明显的目标提取。对比维度连通区域分割✅❌灰度不均背景❌✅算法逻辑局部相似性扩张背景减法式阈值应用举例焊点、颗粒提取字符、污点检测。
基于音频Transformer与动作单元的多模态情绪识别算法设计与实现（在RAVDESS数据集上的应用）
weixin_42380711的博客
05-24 2001
摘要：情感识别技术在医学、自动驾驶等多个领域的广泛应用，正吸引着研究界的持续关注。本研究提出了一种融合语音情感识别（SER）与面部情感识别（FER）的自动情绪识别系统。实验结果显示，通过附加多层感知器进行整体微调时取得最佳准确率，验证了迁移学习相较于从头训练更具鲁棒性，且预训练知识有助于任务适应。在FER方面，通过提取视频动作单元对比静态模型与顺序模型的性能差异，发现两者差异较小。错误分析表明，视觉系统可通过高情绪负载帧检测器进行优化，这为视频情感识别方法研究提供了新思路。
QPSK调制后进行载波同步实现
t19875128的博客
05-26 408
QPSK（Quadrature Phase Shift Keying，正交相移键控）是一种常见的数字调制方式，它通过在正交的两个载波上分别调制两个比特的信息来实现高效的信号传输。在接收端，为了正确解调QPSK信号，需要进行载波同步，以确保接收机能够准确地恢复出发送信号的载波相位和频率。QPSK调制和载波同步的Matlab代码。
Codeforces Round 1027 (Div. 3)
Script_Kids的博客
05-27 293
注：这次只贴代码了, 前面文章还有好几个坑没填呢(哈哈哈)
1267: 【入门】鲜花方阵
ieuxhsj的博客
05-24 601
光明小学艺术节快要来了，老师要求同学们布置一个n * n的花盆方阵（n是奇数，n<=9）；如果n=5，那么方阵的形状如下图所示；如果n=7，那么方阵的形状如下图所示；请读入一个整数n（奇数），输出如图所示的方阵，为了方便输出，用1表示黄色的花盆，0表示红色花盆，输出时数字场宽设置为3。例如：n=5，那么实际要输出的方阵的结果如下n=7，那么实际要输出的方阵的结果如下。
代码随想录算法训练营Day04
03-26
### 关于代码随想录 Day04 的学习资料与解析 #### 一、Day04 主要内容概述 代码随想录 Day04 的主要内容围绕 **二叉树的遍历** 展开，包括前序、中序和后序三种遍历方式。这些遍历可以通过递归实现，也可以通过栈的方式进行迭代实现[^1]。 #### 二、二叉树的遍历方法详解 ##### 1. 前序遍历（Pre-order Traversal） 前序遍历遵循访问顺序：根节点 -> 左子树 -> 右子树。以下是基于递归的实现： ```python def preorderTraversal(root): result = [] def traversal(node): if not node: return result.append(node.val) # 访问根节点 traversal(node.left) # 遍历左子树 traversal(node.right) # 遍历右子树 traversal(root) return result ``` 对于迭代版本，则可以利用显式的栈来模拟递归过程： ```python def preorderTraversal_iterative(root): stack, result = [], [] current = root while stack or current: while current: result.append(current.val) # 访问当前节点 stack.append(current) # 将当前节点压入栈 current = current.left # 转向左子树 current = stack.pop() # 弹出栈顶元素 current = current.right # 转向右子树 return result ``` ##### 2. 中序遍历（In-order Traversal） 中序遍历遵循访问顺序：左子树 -> 根节点 -> 右子树。递归实现如下： ```python def inorderTraversal(root): result = [] def traversal(node): if not node: return traversal(node.left) # 遍历左子树 result.append(node.val) # 访问根节点 traversal(node.right) # 遍历右子树 traversal(root) return result ``` 迭代版本同样依赖栈结构： ```python def inorderTraversal_iterative(root): stack, result = [], [] current = root while stack or current: while current: stack.append(current) # 当前节点压入栈 current = current.left # 转向左子树 current = stack.pop() # 弹出栈顶元素 result.append(current.val) # 访问当前节点 current = current.right # 转向右子树 return result ``` ##### 3. 后序遍历（Post-order Traversal） 后序遍历遵循访问顺序：左子树 -> 右子树 -> 根节点。递归实现较为直观： ```python def postorderTraversal(root): result = [] def traversal(node): if not node: return traversal(node.left) # 遍历左子树 traversal(node.right) # 遍历右子树 result.append(node.val) # 访问根节点 traversal(root) return result ``` 而迭代版本则稍复杂一些，通常采用双栈法或标记法完成： ```python def postorderTraversal_iterative(root): if not root: return [] stack, result = [root], [] while stack: current = stack.pop() result.insert(0, current.val) # 插入到结果列表头部 if current.left: stack.append(current.left) # 先压左子树 if current.right: stack.append(current.right) # 再压右子树 return result ``` #### 三、补充知识点 除了上述基本的二叉树遍历外，Day04 还可能涉及其他相关内容，例如卡特兰数的应用场景以及组合问题的基础模板[^2][^4]。如果遇到具体题目，可以根据实际需求调用相应算法工具。 --- ####
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值