代码随想录Day23：修剪二叉搜索树、将有序数组转换为二叉搜索树、把二叉搜索树转换为累加树

最新推荐文章于 2024-06-15 16:17:24 发布

糖醋圆白菜.

最新推荐文章于 2024-06-15 16:17:24 发布

阅读量119

点赞数 1

文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_47513070/article/details/136197452

版权

修剪二叉搜索树

递归法

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root == NULL) return NULL;
        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;
    }
};

迭代法

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

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

递归法

class Solution {
public:
    TreeNode* test(vector<int>& nums, int left, int right)
    {
        if(left > right) return NULL;
        int mid = left + (right - left)/2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = test(nums, left, mid-1);
        root->right = test(nums,mid+1, right);
        return root;
    }

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

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

递归法

class Solution {
public:
    void test(TreeNode* root, int& pre)
    {
        if(root == NULL) return;
        test(root->right, pre);
        root->val += pre;
        pre = root->val;
        test(root->left, pre);
    }

    TreeNode* convertBST(TreeNode* root) {
        int pre = 0;
        test(root, pre);
        return root;
    }
};

迭代法

class Solution {
public:
    void test(TreeNode* root)
    {
        stack<TreeNode*> st;
        TreeNode* cre = root;
        int pre = 0;
        while(!st.empty() || cre != NULL)
        {
            if(cre != NULL)
            {
                st.push(cre);
                cre = cre->right;
            }
            else
            {
                cre = st.top();
                st.pop();
                cre->val += pre;
                pre = cre->val;
                cre = cre->left;
            }
        }
    }

    TreeNode* convertBST(TreeNode* root) {
        int pre = 0;
        test(root);
        return root;
    }
};