随想录训练营17/60 | LC 654.最大二叉树 ；LC 617.合并二叉树 ；LC 700.二叉搜索树中的搜索 ；LC 98.验证二叉搜索树

LC 654.最大二叉树

题目链接：LC 654.最大二叉树
思路：构建最大二叉树，该二叉树的根节点是数组中的最大值，二叉树的左子树是由最大值的左边递归构建，二叉树的右子树是由最大值的右边递归构建。
思路为：找到最大值，创建val为最大值的根节点，然后利用最大值的id将数组分割开。根节点的左子树是下次递归函数（左数组）的返回值，根节点的右子树是下次递归函数（右数组）的返回值。
代码：

/**
 * 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* traversal(vector<int>& nums){
        //当最大值出现在开始或者末尾，会传递空数组，所以也要先判断
        if(nums.size()==0)return nullptr;
        //创建根节点
        TreeNode* root = new TreeNode(0);
        //当只剩一个节点的时候就直接返回
        if(nums.size()==1){
            root->val = nums[0];
            return root;
        }
        //否则就进行分割
        int maxId=0;//保存最大值的id
        for(int i=0; i<nums.size(); i++){
            if(nums[maxId]<nums[i])maxId = i;//当遍历的节点比保存的节点大，就更新保存的节点
        }
        //找到最大值节点，然后就给节点进行赋值
        root->val = nums[maxId];
        //划分除最大值以外的数组
        vector<int> left(nums.begin(), nums.begin()+maxId);
        vector<int> right(nums.begin()+maxId+1, nums.end());//要跳过中间最大节点
        //进行递归
        root->left = traversal(left);
        root->right = traversal(right);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* root = traversal(nums);
        return root;
    }
};

LC 617.合并二叉树

题目链接：LC 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* root1, TreeNode* root2) {
        //都是空也没关系，也是返回空
        if(root1==nullptr)return root2;
        if(root2==nullptr)return root1;
        //当都不为空时
        root2->val = root2->val + root1->val;//这一句放在这就是前序遍历，也可以换位置变成中序和后序遍历。
        root2->left = mergeTrees(root1->left, root2->left);
        root2->right = mergeTrees(root1->right, root2->right);
        return root2;
    }
};

LC 700.二叉搜索树中的搜索

题目链接：LC 700.二叉搜索树中的搜索
思路：递归遍历，当节点的值等于val就返回，当val大于节点值，就去右子树；当val小于节点值就遍历左子树；当到了空节点就返回null。
代码：

/**
 * 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 val) {
        //终止条件
        if(root==nullptr) return root;
        //单层递归逻辑
        //前序遍历
        int cur = root->val;
        if(cur==val)return root;
        TreeNode* result = nullptr;
        if(cur>val){
            result = searchBST(root->left, val);
        }
        if(cur<val){
            result = searchBST(root->right, val);
        }
        return result;
    }
};

LC 98.验证二叉搜索树

题目链接：LC 98.验证二叉搜索树
思路：判断二叉树是否时二叉搜索树，就前序遍历，看左节点是否小于根节点，看右节点是否大于根节点，若不满足上述条件就返回false；若满足，就继续向下遍历。但是不能只通过根节点大于左节点，小于右节点来判断是否是二叉搜索树。要通过中序遍历来判断节点值是否时单调递增的，用一个全局最大值，来约束后面的值要比前面的值都大，否则不符合单调递增。
还有一种思路：先按照中序遍历二叉树，保存遍历结果。遍历结束之后看数组是否是单调递增。
代码：

/**
 * 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:
    long long max = LONG_MIN;//全局最大值
    bool isValidBST(TreeNode* root) {
        //当到空节点的时候就返回true
        //不能在叶子节点就直接返回，因为需要得到叶子节点的值来更新max
        if(root==nullptr)return true;
        //当不是空节点的时候,就进行中序遍历
        //先左子树
        bool left = isValidBST(root->left);
        //然后中间
        if(root->val>max){
            max = root->val;
        }
        else{
            return false;
        }
        //最终右子树
        bool right = isValidBST(root->right);
        return right && left;
    }
};