本文探讨了如何通过递归和迭代方法修剪二叉搜索树，使其所有节点值落在给定的 [low, high] 区间内，同时保持原有结构。两种方法分别展示了如何遍历、剪枝和重建树的过程，适用于大规模节点的高效处理。
Leetcode（669）——修剪二叉搜索树
题目
给你二叉搜索树的根节点 root，同时给定最小边界 low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在 [low, high] 中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。
示例 1：
输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]
示例 2：
输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]
提示：
- 树中节点数在范围 [1, 10410^4104] 内
- 000 <= Node.val <= 10410^4104
- 树中每个节点的值都是 唯一 的
- 题目数据保证输入是一棵有效的二叉搜索树
- 000 <= low <= high <= 10410^4104
题解
方法一：递归
思路
直接想法就是：递归处理，然后遇到 root->val < low || root->val > high 的时候直接 return nullptr，一波修改，赶紧利落。
然而 [1, 3] 区间在二叉搜索树的中可不是单纯的节点3和左孩子节点0就决定的，还要考虑节点0的右子树。
所以我们在重新关注一下第二个示例，如图：
从图中可以看出需要重构二叉树，想想是不是本题就有点复杂了。
其实不用重构那么复杂。
在上图中我们发现节点0并不符合区间要求，那么将节点0的右孩子 节点2直接赋给 节点3的左孩子就可以了（就是把节点0从二叉树中移除），如图：
完成递归三步：
-
确定递归函数的参数以及返回值
这里我们为什么需要返回值TreeNode*呢？
因为是要遍历整棵树，做修改，其实不需要返回值也可以，我们也可以完成修剪（其实就是从二叉树中移除节点）的操作。
但是有返回值，更方便，可以通过递归函数的返回值来移除节点。 -
确定终止条件
修剪的操作并不是在终止条件上进行的，所以就是遇到空节点返回就可以了。if (root == nullptr ) return nullptr; -
确定单层递归的逻辑
如果 root （当前节点）的元素小于 low 的数值，那么应该递归右子树，并返回右子树符合条件的头结点。
代码如下：if (root->val < low) return trimBST(root->right, low, high); // 寻找符合区间 [low, high] 的节点如果 root （当前节点）的元素大于 high 的，那么应该递归左子树，并返回左子树符合条件的头结点。
代码如下：if (root->val > high) return trimBST(root->left, low, high); // 寻找符合区间 [low, high] 的节点接下来要将下一层处理完左子树的结果赋给 root->left，处理完右子树的结果赋给 root->right。
最后返回 root 节点，代码如下：root->left = trimBST(root->left, low, high); // root->left 接入符合条件的左孩子 root->right = trimBST(root->right, low, high); // root->right 接入符合条件的右孩子 return root;
这多余的节点究竟是如何从二叉树中移除的呢？
在回顾一下上面的代码，针对下图中二叉树的情况：
如下代码相当于把节点0的右孩子（节点2）返回给上一层，
if (root->val < low) return trimBST(root->right, low, high); // 寻找符合区间 [low, high] 的节点
然后如下代码相当于用节点3的左孩子 把下一层返回的 节点0的右孩子（节点2） 接住。
root->left = trimBST(root->left, low, high);
此时节点3的右孩子就变成了节点2，将节点0从二叉树中移除了。
代码实现
Leetcode 官方题解
class Solution {
public:
TreeNode* trimBST(TreeNode* root, int low, int high) {
if (root == nullptr) return root;
if (root->val > high) return trimBST(root->left, low, high); // 从 root 的左子树寻找符合区间 [low, high] 的节点
if (root->val < low) return trimBST(root->right, low, high); // 从 root 的右子树寻找符合区间 [low, high] 的节点
root->left = trimBST(root->left, low, high); // root->left 接入符合条件的左孩子
root->right = trimBST(root->right, low, high); // root->right 接入符合条件的右孩子
return root;
}
};
我的
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
int low_v, high_v;
TreeNode* newroot = nullptr;
TreeNode *lastNode = nullptr;
public:
TreeNode* trimBST(TreeNode* root, int low, int high) {
low_v = low;
high_v = high;
// 第一个大于等于 low ，小于等于 high 的结点为新二叉排序树的根结点 newroot
if(root == nullptr) return root;
if(!find_newroot(root)) return nullptr;
if(newroot == nullptr) return newroot;
leftLow(newroot);
rightHigh(newroot);
return newroot;
}
bool find_newroot(TreeNode* root){
if(low_v <= root->val && root->val <= high_v){
newroot = root;
return true;
}else if(root->val < low_v && root->right != nullptr){
return find_newroot(root->right);
}else if(high_v < root->val && root->left != nullptr){
return find_newroot(root->left);
}else return false;
}
void leftLow(TreeNode* root){
if(root == nullptr) return;
if(low_v < root->val){
lastNode = root;
leftLow(root->left);
}else if(low_v == root->val){
root->left = nullptr;
}else if(low_v > root->val){
if(root->right == nullptr) return;
if(root->right->val < low_v) leftLow(root->left);
lastNode->left = root->right;
leftLow(root->right);
}
return;
}
void rightHigh(TreeNode* root){
if(root == nullptr) return;
if(high_v > root->val){
lastNode = root;
rightHigh(root->right);
}else if(high_v == root->val){
root->right = nullptr;
}else if(high_v < root->val){
if(root->left == nullptr) return;
if(root->left->val > high_v) rightHigh(root->right);
lastNode->right = root->left;
rightHigh(root->left);
}
return;
}
};
复杂度分析
时间复杂度：O(N)O(N)O(N)，其中 NNN 是给定的树的全部节点。我们最多访问每个节点一次。
空间复杂度：O(N)O(N)O(N)，即使我们没有明确使用任何额外的内存，在最糟糕的情况下，我们递归调用的栈可能与节点数一样大。
方法二：迭代
思路
因为二叉搜索树的有序性，所以不需要使用栈模拟递归的过程。
在剪枝的时候，可以分为三步：
- 将 root 移动到 [low, high] 范围内，注意是左闭右闭区间；
- 剪枝左子树；
- 剪枝右子树。
代码实现
class Solution {
public:
TreeNode* trimBST(TreeNode* root, int low, int high) {
if (!root) return nullptr;
// 处理头结点，让 root 移动到 [L, R] 范围内，注意是左闭右闭
while (root != nullptr && (root->val < L || root->val > R)) {
if (root->val < L) root = root->right; // 小于L往右走
else root = root->left; // 大于R往左走
}
TreeNode *cur = root;
// 此时 root 已经在 [L, R] 范围内，处理左孩子元素小于 L 的情况
while (cur != nullptr) {
while (cur->left && cur->left->val < L) {
cur->left = cur->left->right;
}
cur = cur->left;
}
cur = root;
// 此时 root 已经在 [L, R] 范围内，处理右孩子大于 R 的情况
while (cur != nullptr) {
while (cur->right && cur->right->val > R) {
cur->right = cur->right->left;
}
cur = cur->right;
}
return root;
}
};
我的（迭代）
class Solution {
public:
TreeNode* trimBST(TreeNode* root, int low, int high) {
if(root == nullptr) return root;
TreeNode *curr = nullptr, *last = nullptr;
while(root != nullptr){
if(high < root->val){
root = root->left;
}else if(low > root->val){
root = root->right;
}else break;
}
if(root == nullptr) return root;
curr = root->left;
last = root;
while(curr != nullptr){
if(curr->val < low){
curr = curr->right;
last->left = nullptr;
}else{
last->left = curr;
last = curr;
curr = curr->left;
}
}
curr = root->right;
last = root;
while(curr != nullptr){
if(curr->val > high){
curr = curr->left;
last->right = nullptr;
}else{
last->right = curr;
last = curr;
curr = curr->right;
}
}
return root;
}
};
复杂度分析
时间复杂度：O(N)O(N)O(N)，其中 NNN 是给定的树的全部节点。我们最多访问每个节点一次。
空间复杂度：O(1)O(1)O(1)
扫一扫
315
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
