代码随想录算法训练营day23

题目：669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树

参考链接：代码随想录

669. 修剪二叉搜索树

思路：本题要改的节点比较多，个人感觉使用迭代法会非常麻烦，故直接考虑递归法。首先是返回条件，当节点为空的时候返回。然后是节点不为空的时候需要分类讨论，首先是root值大于high时，可以直接只保留左子树，然后是root值小于low时，可以直接只保留右子树，最后是root值位于 [low,high] 时，分别对左右子树进行递归处理。时间复杂度O(n)。

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root){
            return nullptr;
        }
        if(root->val>high){
            return trimBST(root->left,low,high);
        }
        else if(root->val<low){
            return trimBST(root->right,low,high);
        }
        else{
            TreeNode* left=trimBST(root->left,low,high);
            TreeNode* right=trimBST(root->right,low,high);
            root->left=left;
            root->right=right;
            return root;
        }
    }
};

做完本题感觉自己对递归已经有一定深度的理解了。
看完标答还可以用BST的特性写迭代法，但不是很好理解：

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        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;
    }
};

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

思路：本题要求构造平衡的BST，故我们使用中点分割即可，最后对分割后的两边分别递归，比较容易想到。

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.empty()){
            return nullptr;
        }
        int mid=nums.size()/2;
        TreeNode* node=new TreeNode(nums[mid]);
        vector<int> leftNums(nums.begin(),nums.begin()+mid);
        vector<int> rightNums(nums.begin()+mid+1,nums.end());
        node->left=sortedArrayToBST(leftNums);
        node->right=sortedArrayToBST(rightNums);
        return node;
    }
};

回忆以前做过的最大二叉树，我们可以确保不使用额外空间，优化代码：

class Solution {
public:
    TreeNode* traverse(vector<int>& nums,int begin,int end){
        if(begin>=end){
            return nullptr;
        }
        int mid=(begin+end)/2;
        TreeNode* node=new TreeNode(nums[mid]);
        int leftBegin=begin;
        int leftEnd=mid;
        int rightBegin=mid+1;
        int rightEnd=end;
        node->left=traverse(nums,leftBegin,leftEnd);
        node->right=traverse(nums,rightBegin,rightEnd);
        return node;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traverse(nums,0,nums.size());
    }
};

迭代法pass

538.把二叉搜索树转换为累加树

思路：首先看这道题的计算顺序，是右->中->左，和中序遍历相反。就是反中序遍历BST，并在遍历过程中完成累加，我们依旧使用pre和cur的双指针法。时间复杂度O(n)。

class Solution {
public:
    TreeNode* pre=nullptr;
    int sum=0;
    void traversal(TreeNode* root){
        if(!root){
            return;
        }
        TreeNode* cur=root;
        traversal(root->right);
        if(pre){//不是第一个节点
            root->val+=sum;
        }
        sum=root->val;
        pre=root;
        traversal(root->left);
    }
    TreeNode* convertBST(TreeNode* root) {
        traversal(root);
        return root;
    }
};

看完标答发现可以不用指针，直接记录值即可，迭代法pass。