Day20| Leetcode 654. 最大二叉树 Leetcode 617. 合并二叉树 Leetcode 700. 二叉搜索树中的搜索 Leetcode 98. 验证二叉搜索树

Leetcode 654. 最大二叉树

题目链接 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 {
    private:
    TreeNode* traversal(vector<int>& nums,int left,int right){
        // 在左闭右开区间[left, right)，构造二叉树
        if(left >= right){
            return nullptr;
        }
        // 分割点下标：maxValueIndex
        int maxValueIndex = left;
        for(int i=left+1;i<right;i++){
            if(nums[i] > nums[maxValueIndex]){
                maxValueIndex = i;
            }
        } 
        TreeNode* root = new TreeNode(nums[maxValueIndex]);
        //要注意左闭右开
        root->left = traversal(nums,left,maxValueIndex);

        root->right = traversal(nums,maxValueIndex+1,right);

        return root;
    }
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
            return traversal(nums,0,nums.size());
    }
};

Leetcode 617. 合并二叉树

题目链接 617 合并二叉树

首先要审准题目（怎么合并的），主要是对于两个二叉树的遍历没有做过，首先递归法，两个二叉树同时遍历，将root2的节点值赋给root1，不停递归即可。下面上代码：

/**
 * 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 == NULL){
            return root2;
        }
        if(root2 == NULL){
            return root1;
        }
        root1->val+=root2->val;//中
        root1->left = mergeTrees(root1->left,root2->left);//左
        root1->right = mergeTrees(root1->right,root2->right);//右
        return root1;
    }
};

另一种方法 迭代法（层序遍历），其实和二叉树是否对称是一个思路，运用队列的存储层节点的方式，下面上代码：

/**
 * 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* t1, TreeNode* t2) {
        if(t1 == NULL){
            return t2;
        }
        if(t2 == NULL){
            return t1;
        }
        queue<TreeNode*> que;
        que.push(t1);
        que.push(t2);
        while(!que.empty()){
            TreeNode* node1 = que.front();que.pop();
            TreeNode* node2 = que.front();que.pop();

            node1->val += node2->val;

            if(node1->left!=NULL&&node2->left!=NULL){
                que.push(node1->left);
                que.push(node2->left);
            }

            if(node1->right!=NULL&&node2->right!=NULL){
                que.push(node1->right);
                que.push(node2->right);
            }
            if(node1->left == NULL&&node2->left!=NULL){
                  node1->left = node2->left;
            }
             if(node1->right == NULL&&node2->right!=NULL){
                node1->right = node2->right;
            }
        }
        return t1;

    }
};

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

题目链接 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 val) {
        if (root == NULL || root->val == val) return root;
        if (root->val > val) return searchBST(root->left, val);
        if (root->val < val) return searchBST(root->right, val);
        return NULL;
    }
};

迭代法：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while (root != NULL) {
            if (root->val > val) root = root->left;
            else if (root->val < val) root = root->right;
            else return root;
        }
        return NULL;
    }
};

Leetcode 98. 验证二叉搜索树

题目链接 98 验证二叉搜索树

本题目我觉得考察的还是二叉搜索树的特征，我们要求左子树的全部节点都要小于根节点并且两者要同时小于右子树节点，并且在小子树中也要满足这个条件，要注意二叉树为空时，也是二叉搜索树，大体思路就是：
一个一个比较（遍历后的节点）是不是单调递增的即可。

下面上代码：

/**
 * 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 = NULL;
    bool isValidBST(TreeNode* root) {
        if(root == NULL){
            return true;
        }
        bool left = isValidBST(root->left);
        if(pre!=NULL&&pre>root->val){
            return false;
        }
        pre = root;
        bool right = isValidBST(root->right);
        return left && right;//如果左右子树都符合要求，就返回true
    }
};

end；