Leetcode（669）——修剪二叉搜索树

SmileGuy17

于 2022-06-03 14:10:13 发布

阅读量198

点赞数

分类专栏： Leetcode 文章标签： leetcode 数据结构算法

本文链接：https://blog.csdn.net/KCDCY/article/details/125111778

版权

Leetcode 专栏收录该内容

77 篇文章 6 订阅

订阅专栏

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, $10^4$ ] 内
$0$ <= Node.val <= $10^4$
树中每个节点的值都是唯一的
题目数据保证输入是一棵有效的二叉搜索树
$0$ <= low <= high <= $10^4$

题解

方法一：递归

思路

直接想法就是：递归处理，然后遇到 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)$ ，其中 $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;
    }
};