代码随想录算法训练营第17天 |654.最大二叉树 ， 617.合并二叉树 , 700.二叉搜索树中的搜索,98.验证二叉搜索树

654.最大二叉树

654. 最大二叉树 - 力扣（LeetCode）

class Solution {
public:
    TreeNode* travel(vector<int>& nums,int left,int right){
        if(left >= right) return nullptr;
        int max = INT_MIN;
        int index = 0;
        for(int i= left; i < right;i++) {
            if(nums[i] > max){
                max = nums[i];
                index = i;
            }
        }
        TreeNode* node = new TreeNode(max);
        node->left = travel(nums, left, index);
        node->right = travel(nums, index + 1, right);
        return node;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int n = nums.size();
        return travel(nums, 0, n);
    }
};

617.合并二叉树

617. 合并二叉树 - 力扣（LeetCode）

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        int new_val = 0;
        if(root1 == nullptr && root2 == nullptr){
            return nullptr;
        }else if(root1 == nullptr){
            new_val = root2->val;
        }else if(root2 == nullptr){
            new_val = root1->val;
        }else{
            new_val = root1->val + root2->val;
        }
        TreeNode* new_root = new TreeNode(new_val);
        if(root1 == nullptr){
            new_root->left = mergeTrees(nullptr, root2->left);
            new_root->right = mergeTrees(nullptr, root2->right);
        }else if(root2 == nullptr){
            new_root->left = mergeTrees(root1->left, nullptr);
            new_root->right = mergeTrees(root1->right, nullptr);
        }else{
            new_root->left = mergeTrees(root1->left, root2->left);
            new_root->right = mergeTrees(root1->right, root2->right);           
        }
        return new_root;
    }
};

700.二叉搜索树中的搜索

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

class Solution {
public:
    void travel(TreeNode* root, int val, TreeNode* &result){
        if(root == nullptr){
            return ;
        }
        if(root->val == val){
            result = root;
        }else if(root->val > val){
            travel(root->left, val, result);
        }else{
            travel(root->right, val, result);
        }
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* result = new TreeNode(); 
        travel(root, val, result);
        if(result->val != val){
            return nullptr;
        }
        return result;
    }
};

98.验证二叉搜索树 

98. 验证二叉搜索树 - 力扣（LeetCode）

class Solution {
public:
    vector<int> inorder(TreeNode* root, vector<int>& ls)
    {
        if(root == nullptr)
        {
            return ls;
        }
        inorder(root->left, ls);
        ls.push_back(root->val);
        inorder(root->right, ls);
        return ls;
    }
    bool isValidBST(TreeNode* root) {
        vector<int> ls;
        inorder(root, ls);
        return std::is_sorted(ls.begin(), ls.end());
    }
};