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, 1 0 4 10^4 104] 内
- 0 0 0 <= Node.val <= 1 0 4 10^4 104
- 树中每个节点的值都是 唯一 的
- 题目数据保证输入是一棵有效的二叉搜索树
- 0 0 0 <= low <= high <= 1 0 4 10^4 104
题解
方法一:递归
思路
直接想法就是:递归处理,然后遇到 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),其中
N
N
N 是给定的树的全部节点。我们最多访问每个节点一次。
空间复杂度:
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),其中
N
N
N 是给定的树的全部节点。我们最多访问每个节点一次。
空间复杂度:
O
(
1
)
O(1)
O(1)