代码随想录训练营第23天|669.修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树

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

669.修剪二叉搜索树

修剪二叉搜索树，加入我们访问到了空节点，我们理所应当要返回一个nullptr。
如果我们访问的节点的值大于上界high，我们就返回这个节点的左孩子的剪枝结果。
同理，如果节点的值小于下界low，我们返回这个节点的有孩子的剪枝结果。
如果，节点的值等于上界或下界，我们让它的右孩子或者左孩子指向空，并且 让它的左孩子或右孩子进行剪枝。

代码

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

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

很容易想到的思路，就是进行递归，如果数组为空数组，直接返回NULL。
如果不为空，就把中间的节点当成根节点进行下一轮的递归。
就是中间节点的左面构建成左子树。中间节点的右面元素构建成右子树。

代码

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size()==0) return NULL;
        else if(nums.size()==1) return new TreeNode(nums[0]);
            int mid = nums.size()/2;
            TreeNode*p = new TreeNode(nums[mid]);
            vector<int> leftv(nums.begin(),nums.begin()+mid);
            p->left = sortedArrayToBST(leftv);
            vector<int> rightv(nums.begin()+mid+1,nums.end());
            p->right = sortedArrayToBST(rightv);
            return p;
    }
};

这样子很好想，但是时间复杂度很高，本人想了想，应该是调用size函数时，把数组又访问了一边，如果调整这个时间复杂度的话，可以再创建一个函数，直接调用下标即可，这样子会降低复杂度

优化代码

class Solution {
private:
    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;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

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

很显然，我们要把最大的值累计加起来，因此，我们访问到一个节点时候，需要用的其右孩子的信息，访问左孩子的时候，需要根节点和右孩子的信息。
因此，我们应该采取，右中左的遍历顺序。
因此，我们定义一个全局遍历sum，初始化为0.
如果右孩子存在，就访问右孩子
之后让sum+=root.val
并让根节点的值等于sum
如果左孩子存在，访问左孩子。
返回根节点即可。

代码

class Solution {
public:
int sum = 0;
    TreeNode* traval(TreeNode*root)
{
        if(root->right)
         root->right =  traval(root->right);
        sum+=root->val;
        root->val = sum;
        if(root->left)
        root->left = traval(root->left);
        return root;
}
    TreeNode* convertBST(TreeNode* root) {
        if(root==nullptr) return nullptr;
        root = traval(root);
        return root;
    }
};