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

文档讲解：
递归，层序遍历，BFS，DFS

654.最大二叉树

思路：这道题的思路跟之前利用前序遍历和中序遍历的数组来构造二叉树是一样的，抓住的关键点就是每个树的根节点，如何分割出来左子树和右子树！

class Solution {
public:
    int mymax(vector<int> nums)
    {
        int result=INT_MIN;
        for(auto i=nums.begin();i!=nums.end();++i)
        {
            result=result>*i?result:*i;
        }
        return result;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==0) return nullptr;
        int rootvalue=mymax(nums);
        TreeNode* root=new TreeNode(rootvalue);
        int deindex;
        for(deindex=0;deindex<nums.size();deindex++)
        {
            if(nums[deindex]==rootvalue)break;
        }
        vector<int> lefttree(nums.begin(),nums.begin()+deindex);
        vector<int> righttree(nums.begin()+deindex+1,nums.end());
        root->left=constructMaximumBinaryTree(lefttree);
        root->right=constructMaximumBinaryTree(righttree);
        return root;
    }
};

617.合并二叉树

思路：这道题最开始还是没想清楚这个逻辑，产生这个新节点应该怎么去讨论！

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

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

思路：最开始拿到这道题的时候，我使用的是层序遍历来做，虽然也能做出来，但是有点不够好，因为这是一道二叉搜索树中的搜索问题，其有一个性质没有利用，其左子树一定是小于根节点，右子树一定是大于根节点的！故重新写了递归版本。

层序遍历：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr)return nullptr;
        queue<TreeNode*>que;
        que.push(root);
        TreeNode* result=nullptr;
        while(!que.empty())
        {
            int size=que.size();
            while(size--)
            {
                TreeNode* cur=que.front();
                que.pop();
                if(cur->val==val)
                {
                    result=cur;
                    break;
                }
                if(cur->left)que.push(cur->left);
                if(cur->right)que.push(cur->right);
            }

        }
        return result;
    }
};

递归法：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr||root->val==val)return root;
        TreeNode* result=nullptr;
        if(root->val<val)result=searchBST(root->right,val);
        if(root->val>val)result=searchBST(root->left,val);
        return result;
    }
};

98.验证二叉搜索树

思路：这个题得把中序遍历联系起来，有两种做法！

class Solution {
public:
    long long maxVal=LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr)return true;
        bool left=isValidBST(root->left);
        if(maxVal<root->val)maxVal=root->val;
        else return false;
        bool right=isValidBST(root->right);
        return left&&right;
    }
};

class Solution {
public:
    void inoreder(TreeNode* root,vector<int>& result)
    {
        if(root==nullptr)return;
        inoreder(root->left,result);
        result.push_back(root->val);
        inoreder(root->right,result);
    }
    bool isValidBST(TreeNode* root) {
        vector<int>result;
        inoreder(root,result);
        for(int i=0;i<result.size()-1;i++)
        {
            if(result[i]>=result[i+1])return false;
        }
        return true;
    }
};