代码随想录算法训练营Day23| 669. 修剪二叉搜索树 ， 108.将有序数组转换为二叉搜索树 ， 538.把二叉搜索树转换为累加树

今天这第一题我是真的有点醍醐灌顶了，在听到解析之后，我没有考虑到的情况是不能直接return他的left或者right，因为他的left或者right里还有不符合条件的，所以这里应该返回的是修剪过后的left或者right，这里真的很容易搞错，一开始就以为是一个简单的找到，然后再用之前的删除节点的操作就可以了，来看一下具体代码的实现

TreeNode* trimBST(TreeNode* root, int low, int high) {
        return CutNode(root,low,high);
    }
    TreeNode* CutNode(TreeNode* &root, int low,int high){
        if(root==NULL) return NULL;
        root->left = CutNode(root->left,low,high);
        if(root->val<low || root->val>high){
            if(root->left==NULL && root->right==NULL){
                return NULL;
            }
            else if(root->left==NULL && root->right!=NULL){
                return CutNode(root->right,low,high);
            }
            else if(root->left!=NULL && root->right==NULL){
                return CutNode(root->left,low,high);
            }
            else if(root->left!=NULL && root->right!=NULL){
                TreeNode* p=root->left;
                while(p->right!=NULL){
                    p=p->right;
                }
                if(p==root->left){
                    p->right=root->right;
                    return CutNode(root->left,low,high);
                }
                else{
                    p->right=root->right;
                    return CutNode(root->left,low,high);
                }
            }
        }
        root->right=CutNode(root->right,low,high);
        return root;
    }

这里其实不用额外定义一个函数，首先是递归的终止条件，当节点为NULL时，就直接返回NULL，然后就是中序遍历，用root的left来接收修建过后的左子树，后面的右子树也是一样的，然后就是单层递归的逻辑，只要这个结点的数值不满足题目的条件，那就先判断，如果是左右子树只存在一个的情况，那就分别返回他们左右子树修剪过后的值，如果是都存在的情况，那就是返回拼接好后的然后再修减过后的值，最后再返回根节点就可以了

TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size()==0) return NULL;
        int mid=nums.size()/2;
        TreeNode* root=new TreeNode(nums[mid]);
        vector<int> leftnums;vector<int> rightnums;
        for(int i=0;i<mid;i++) leftnums.push_back(nums[i]);
        for(int i=mid+1;i<nums.size();i++) rightnums.push_back(nums[i]);
        root->left=sortedArrayToBST(leftnums);
        root->right=sortedArrayToBST(rightnums);
        return root;
    }

class Solution {
public:
        TreeNode* convertBST(TreeNode* root) {
        int sum=count(root);
        int c=0;
        ordered(root,sum,c);
        return root;
    }
    void ordered(TreeNode* &root,int sum,int &c){
        if(root==NULL) return ;
        ordered(root->left,sum,c);
        c+=root->val;
        root->val=sum-c+root->val;
        ordered(root->right,sum,c);
    }
    int count(TreeNode* root){
        if(root==NULL) return 0;
        int sum=root->val;
        int sumleft=count(root->left);
        int sumright=count(root->right);
        return sum+sumleft+sumright;
    }
};