第四周第一天|力扣654、最大二叉树 617、合并二叉树 700、二叉搜索树中的搜索 98、验证二叉搜索树

力扣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) {}
 * };
 */
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
                TreeNode* node=new TreeNode(0);
                if(nums.size()==1){
                    node->val=nums[0];
                    return node;
                }
                //中间节点的处理，选择元素值最大的节点作为中间节点，区分左右子树
                int index=0;
                int maxValue=0;
                for(int i=0;i<nums.size();i++){
                    if(nums[i]>maxValue){//更新
                        maxValue=nums[i];
                        index=i;
                    }
                }
                node->val=maxValue;
                //左区间要有元素的话，index>=1
                if(index>0){
                    vector<int> newVec(nums.begin(),nums.begin()+index);
                    node->left=constructMaximumBinaryTree(newVec);
                }
                //右区间要保证有元素，index<nums.size()-1
                if(index<nums.size()-1){
                    vector<int> newVec(nums.begin()+index+1,nums.end());
                   node->right= constructMaximumBinaryTree(newVec);
                }
                return node;
    }
};

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;
        //采用改变二叉树结构的前序遍历来解决
        root1->val+=root2->val;
        root1->left=mergeTrees(root1->left, root2->left);
        root1->right=mergeTrees(root1->right, root2->right);
        return root1;
    }
};

700、二叉搜索树中的搜索

分析：题目要我们找二叉搜索树中的某个特定值的节点，并返回该节点的值，如果是普通二叉树，我去遍历就可以了，但这是一棵二叉搜索树，也就是说，按照左中右中序遍历的顺序遍历这颗二叉树的话，那么所得到的结果应该是一个升序的序列，利用这个特性，我们只要一路根据比较的结果往下走就可以了，当前节点的值比该值大就往左走，反之则反，找到空都没有就返回nullptr

代码：

/**
 * 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||root->val==val)return root;
        TreeNode* result;
        if(root->val<val){
            result=searchBST(root->right, val);
        }
        if(root->val>val){
            result=searchBST(root->left, val);
        }
        return result;
    }
};

98、验证二叉搜索树

思路：验证一棵树是否是二叉搜索树，最直白的想法就是用中序遍历去遍历这颗二叉树，然后用一个数组将遍历到的元素都保存下来，最后检查该数组是否是升序的就可以判断该树是否是BST了。用中序去遍历当然没问题，但是仔细想想，我们并不需要设置一个数组去保存二叉树中的元素吧，实际上我们只需要用两个指针去中序遍历，如果该树真的是二叉搜索树，那么前面的节点指针的值一定是要小于后面节点指针的值的，因此，用这种方式我们能够更加方便的做出判断，代码如下。

注意：一旦题目中提到二叉搜索树，我们就应该想到能不能使用中序遍历，这是二叉搜索树的特性给我们的启示。

代码：

/**
 * 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* pre=nullptr;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr)return true;//空节点既是满二叉树，也是完全二叉树，也是二叉搜索树
        //左，递归左子树
        bool left=isValidBST(root->left);
        //中，处理节点的逻辑
        if(pre!=nullptr&&root->val<=pre->val)return false;
        pre=root;//用pre来保存前一个节点的值
        //右，递归右子树
        bool right=isValidBST(root->right);
        return left&&right;
    }
};