代码随想录day17|654，617,700,98

最新推荐文章于 2024-08-23 17:54:32 发布

qq_19555169

最新推荐文章于 2024-08-23 17:54:32 发布

阅读量120

点赞数 3

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_19555169/article/details/140900163

版权

文章链接：

代码随想录代码随想录PDF，代码随想录网站，代码随想录百度网盘，代码随想录知识星球，代码随想录八股文PDF，代码随想录刷题路线，代码随想录知识星球八股文https://programmercarl.com/0654.%E6%9C%80%E5%A4%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html代码

654

/**
 * 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) {}
 * };
 */
 #include<vector>
 #include<climits>
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return build(nums,0,nums.size()-1);
    }
    TreeNode* build(std::vector<int>&nums,int lo,int hi){
        if(lo > hi){
            return nullptr;
        }

        int index = -1,maxVal = INT_MIN;
        for(int i = lo;i <=hi;i++){
            if(maxVal < nums[i]){
                index = i;
                maxVal = nums[i];
            }
        }
        TreeNode* root = new TreeNode(maxVal);
        root->left = build(nums,lo,index-1);
        root->right = build(nums,index+1,hi);

        return root;
    }
};

617

/**
 * 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* mergeTrees(TreeNode* a, TreeNode* b) {
        if(!a && !b) return nullptr;
        if(!a)  return b;
        if(!b)  return a;

        a->val += b->val;
        a->left = mergeTrees(a->left,b->left);
        a->right = mergeTrees(a->right,b->right);

        return a;
    }
};

700

/**
 * 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* searchBST(TreeNode* root, int target) {
        if(root == nullptr){
            return nullptr;
        }
        if(root->val > target){
            return searchBST(root->left,target);
        }
        if(root->val < target){
            return searchBST(root->right,target);
        }
        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:
    bool isValidBST(TreeNode* root) {
        return isValidBST(root,nullptr,nullptr);
    }

    bool isValidBST(TreeNode* root,TreeNode* min,TreeNode* max){
        if(root == nullptr) return true;

        if(min != nullptr && root->val <=min->val) return false;
        if(max!= nullptr && root->val >=max->val) return false;

        return isValidBST(root->left,min,root)
                && isValidBST(root->right,root,max);
                
    }
};