代码随想录算法训练营第二十三天|Leetcode669 修剪二叉搜索树、Leetcode108 将有序数组转换为二叉搜索树、Leetcode538 把二叉搜索树转换为累加树

● Leetcode669 修剪二叉搜索树

题目链接：Leetcode669 修剪二叉搜索树
视频讲解：代码随想录|修剪二叉搜索树
题目描述：给你二叉搜索树的根节点 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]之外的所有结点删除，同时还要保持二叉搜索树的结构。
整体解题思路： 二叉搜索树的特性为左子树结点均小于根结点，右子树结点均大于根结点。遍历到结点cur时，当cur->val < low ，则其左子树元素均小于low，需要直接向删除结点的右子树遍历；而当 cur->val > high，其右子树元素均大于high，需要直接向删除节点的左子树遍历。

方法一：递归
在整体解题思路的基础上，我们需要注意：

//对删除结点的左子树进行剪枝
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;
}

这里需要先将左右结点保留，因为对于删除结点而言，其左子树或者右子树能肯定排除在范围外，但剩余一部分子树的元素仍然需要进行判断是否满足条件，需要继续向下修建，保留返回内的元素结点。

方法二：迭代
使用迭代完成修建二叉搜索树，我们需要进行以下：
（1）当root->val不在范围内，我们需要将root向左移动或者向右移动，使其在[low, high]中；
（2）当发现结点cur和cur->right存在且cur->val < low时，我们将右孩子连接到给cur的父结点，然后移动cur向下继续判断修剪；
（3）当发现结点cur和cur->left存在且cur->val > high时，我们将左孩子连接到cur的父结点，然后向下移动。

● 代码实现

方法一：递归

/**
 * 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 {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root) return nullptr;

        //对删除结点的左子树进行剪枝
        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;
    }
};

方法二：迭代

/**
 * 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 {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root) return nullptr;

        //将root移动到[low, high]范围内
        while(root && (root->val < low || root->val > high))
        {
            if(root->val < low) root = root->right;
            else root = root->left;
        }

        TreeNode* cur = root;

        //删除结点，但保留右子树进行后续处理
        while(cur != nullptr)
        {
            while(cur->left != nullptr && cur->left->val < low)
            {
                cur->left = cur->left->right;
            }
            cur = cur->left;
        }

		//重置cur到根结点进行右子树修建
        cur = root;
        删除结点，但保留左子树进行后续处理
        while(cur != nullptr)
        {
            while(cur->right != nullptr && cur->right->val > high)
            {
                cur->right = cur->right->left;
            }
            cur = cur->right;
        }
        return root;
    }
};

● Leetcode108 将有序数组转换为二叉搜索树

题目链接：Leetcode108 将有序数组转换为二叉搜索树
视频讲解：代码随想录|将有序数组转换为二叉搜索树
题目描述：给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 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 按 严格递增 顺序排列

● 解题思路

对于构建平衡的二叉搜索树，因为给定的数组按严格递增顺序排列，我们在构建二叉搜索树的过程中不需要担心太多，重点在于我们如何构建的二叉搜索树是平衡的？
最简单的方式就是左子树和右子树在构建过程中保持元素基本相等，也就是说我们将数组的中位数作为根，就能保证其左右元素相等，然后递归构建左右子树即可。

● 代码实现

//递归
/**
 * 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 {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right)
    {
        if(left > right) return nullptr;

        int mid = left + (right - left) / 2;
        TreeNode* root = new TreeNode(nums[mid]);

        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traversal(nums, 0, nums.size() - 1);
    }
};

● Leetcode538 把二叉搜索树转换为累加树

题目链接：Leetcode538 把二叉搜索树转换为累加树
视频讲解：代码随想录|把二叉搜索树转换为累加树
题目描述：给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：
节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。
注意：本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 相同

示例 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 之间。
· 树中的所有值 互不相同 。
· 给定的树为二叉搜索树。

● 解题思路

关于把二叉搜索树转换为累加树 可以理解为中序遍历数组中，从最后一个元素开始，不断将结果累加到前一个元素上，以示例一为例：

中序遍历输出：0 1 2 3 4 5 6 7 8
我们从最后一个值开始向前累加得到：36 36 35 33 30 26 21 15 8

不难看出需要采用的遍历顺序还是中序遍历，只不过需要做一点小小的改动，先遍历右，再处理中，最后遍历左。
有了大体思路，我们需要考虑单层处理逻辑：
我们需要定义一个pre从最后一个元素开始记录其数据值，然后将遍历结点直接与pre累加，再令pre记录累加后的cur->val帮助后续结点进行累加。

使用迭代法解决思路相同，需要使用栈模拟递归的过程，同样需要pre记录前面累加的值。

● 代码实现

方法一：递归

/**
 * 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 {
public:
    int pre;
    void traversal(TreeNode* cur)
    {
        if(cur == nullptr) return;

        traversal(cur->right); //右
        cur->val += pre;
        pre = cur->val;//中
        traversal(cur->left);
    }
    TreeNode* convertBST(TreeNode* root) {
        if(root == nullptr) return nullptr;
        traversal(root);
        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 {
public:
    int pre;
    TreeNode* convertBST(TreeNode* root) {
        if(root == nullptr) return nullptr;

        stack<TreeNode*> st;
        pre = 0;
        TreeNode* cur = root;

        while(cur != nullptr || !st.empty())
        {
            if(cur)
            {
                st.push(cur);
                cur = cur->right; //右
            }
            else
            {
                cur = st.top(); st.pop();
                cur->val += pre;
                pre = cur->val; //中

                cur = cur->left;
            }
        }
        return root;
    }
};