【代码随想录训练营第42期 Day21打卡二叉树Part8-LeetCode 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树-CSDN博客

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

题解：递归

有了上边对于二叉搜索树的回顾，这道题其实不难。

首先我们要知道递归的终止条件，这里很明显，就是当前节点为空的时候。

然后我们根据不同情况不同分析。当前节点不为空的时候，有两种情况：

一是当前节点就是需要删除的节点（即小于low或者大于high），我们根据二叉搜索树的性质：如果小于low则左子树全小于low，递归返回右子树不断遍历即可；如果大于high则右子树全大于high，递归返回左子树不断遍历即可。

二是当前节点位于区间[low,high]，即满足条件，不需要删除，这时候我们通过对左右子树分别进行递归修剪既可。

代码如下：

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (root == nullptr)    return nullptr;             //递归终止条件
        if (root->val < low)    return trimBST(root->right, low, high);         //当前节点值小于low，根据二叉树性质，它的左子树所有节点值都小于low，故满足区间内的节点都在右子树中
        if (root->val > high)   return trimBST(root->left, low, high);          //当前节点值大于high，根据二叉树性质，它的右子树所有节点值都大于high，故满足区间内的节点都在左子树中
        else {              //当前节点处于[low,high]中时，我们只需分别递归的修剪当前节点的左右子树
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        }
        return root;
    }
};

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

题目链接

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵

平衡
二叉搜索树。

示例 1：
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
示例 2：
输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。
提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 按 严格递增 顺序排列

题解：递归

这个题题目已经很清楚了，就是将有序数组（这道题甚至帮我们排好序了）转换为二叉搜索树。

首先我们要知道根节点取的是哪个位置：通过题目给的样例，根节点都是取的有序数组的中间元素，这里我们把这个位置记作mid，其中mid = left + (right - left) / 2（是不是想起了二分）。知道了根节点取得值之后，我们就可以创建一棵树作为结果，其中根节点的值为nums[mid]。

然后我们得知道递归的终止条件，这里也很显然，当left > right的时候，要处理的部分数组区间失去了意义，即此时子树为空。

最后就是通过递归不断构建左右子树--递归实现了左右子树进行了以上同样的操作。

class Solution {
public:
    TreeNode* dfs(vector<int>& nums, int left, int right) {
        if (left > right)       return nullptr;        //递归终止条件：left > right，说明当前要处理的数组部分为空，该部分不再存在子树
        int mid = left + (right - left) / 2;          //得到mid位置，nums[mid]对应根节点的值
        TreeNode* root = new TreeNode(nums[mid]);           //创建一棵树，根节点值为nums[mid]
        //递归构建二叉树的左右子树
        root->left = dfs(nums, left, mid - 1);
        root->right = dfs(nums, mid + 1, right);
        return root;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return dfs(nums, 0, nums.size() - 1);
    }
};

题目三：538.把二叉搜索树转换为累加树

题目链接

538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。
节点的右子树仅包含键大于节点键的节点。
左右子树也必须是二叉搜索树。

注意：本题和 1038: . - 力扣（LeetCode）相同

示例 1：
输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
示例 2：
输入：root = [0,null,1]
输出：[1,null,1]
示例 3：
输入：root = [1,0,2]
输出：[3,3,2]
示例 4：
输入：root = [3,2,4,1]
输出：[7,9,4,10]
提示：

树中的节点数介于 0 和 104 之间。
每个节点的值介于 -104 和 104 之间。
树中的所有值 互不相同 。
给定的树为二叉搜索树。

题解：反序中序遍历（递归）

这道题就要用到上面回顾的内容了：反序中序遍历。为什么会想到这个思路呢？其实我们同过题意可以发现我们要得出大于等于当前节点的值（包括当前节点）的和，那么自然就是可以按照所有节点从大往小的顺序排序，将满足大于等于当前的节点的值依次累加即可。而反序中序遍历成功的实现了得到单调递减的有序序列这一想法，根据右-根-左的顺序遍历递归。

代码如下：

class Solution {
public:
    int sum = 0;            //记录求和
    TreeNode* convertBST(TreeNode* root) {
        if (root == nullptr)    return nullptr;        //递归终止条件：当前节点为空
        convertBST(root->right);         //右：右子树的所有节点值都大于当前节点，先进行累加操作
        sum += root->val;                //根：将当前节点值加到sum上
        root->val = sum;                       //更新当前节点的值为sum，即树中大于或等于该节点值的所有节点的值之和 
        convertBST(root->left);          //左：递归处理左子树（通过递归遍历左子树的全部节点）
        return root;
    }
};