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

654.最大二叉树

题目链接654. 最大二叉树 - 力扣（LeetCode）

讲解链接 代码随想录 (programmercarl.com)

 本题题目中就给出建议：根据最大值左右递归地构建二叉树，再结合前一天的切片构建二叉树的知识，还是不难写出如下代码：

/**
 * 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:
    int max(vector<int>&nums){
        int temp=INT_MIN;
        for(int i=0;i<nums.size();i++){
            if(nums[i]>temp){
                temp=nums[i];
            }
        }
        return temp;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode*root=new TreeNode(0);

        if(nums.size()==1){
            root->val=nums[0];
            return root;
        }
        int rootValue=max(nums);
        root->val=rootValue;
        int index;
        for(index=0;index<nums.size()-1;index++){
            if(nums[index]==rootValue)
            break;
        }
        
        

        if(index>0){
            
            vector<int>left(nums.begin(),nums.begin()+index);
            root->left=constructMaximumBinaryTree(left);
            
        }
        if(index<nums.size()-1){
            
            vector<int>right(nums.begin()+index+1,nums.end());
            root->right=constructMaximumBinaryTree(right);
        }
        return root;
    }
};

其中，判断切片部分刚开始想的时候没想好写成了：

vector<int>left(nums.begin(),nums.begin()+index);
vector<int>right(nums.begin()+index+1,nums.end());

if(index>0){
            
            
            root->left=constructMaximumBinaryTree(left);
            
        }
        if(index<nums.size()-1){
            
            
            root->right=constructMaximumBinaryTree(right);
        }

无疑是忘记了最大元素在边界的情况。

617.合并二叉树

题目链接 617. 合并二叉树 - 力扣（LeetCode）

讲解链接 代码随想录 (programmercarl.com)

 本题采用了本方法：每种情况逐次判断，并分别合并递归。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==NULL&&root2==NULL)return NULL;
        TreeNode*root=new TreeNode(0);
        if(root1!=NULL&&root2==NULL){
            root->val=root1->val;
            root->left=mergeTrees(root1->left,NULL);
            root->right=mergeTrees(root1->right,NULL);
        }
        if(root2!=NULL&&root1==NULL){
            root->val=root2->val;
            root->left=mergeTrees(NULL,root2->left);
            root->right=mergeTrees(NULL,root2->right);

        }
        if(root1!=NULL&&root2!=NULL){
            root->val=root1->val+root2->val;
            root->left=mergeTrees(root1->left,root2->left);
            root->right=mergeTrees(root1->right,root2->right);
        }
        return root;

    }
};

700.二叉搜索树中的搜索

题目链接 700. 二叉搜索树中的搜索 - 力扣（LeetCode）

讲解链接 代码随想录 (programmercarl.com)

 第一次做的时候没有注意到搜索二叉树的概念：

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

 这就导致了它的搜索方法可以采用比较大小的方式，同时返回参数类型一直没搞明白，尤其是对于答案：

if(root==NULL||root->val==val)return root;

这样下去每次返回的地址要么是目标、要么是空。

98.验证二叉搜索树

题目链接 98. 验证二叉搜索树 - 力扣（LeetCode）

讲解链接 代码随想录 (programmercarl.com)

 自己做一次发现果然踏入了陷阱：

class Solution {
public: 

    bool isValidBST(TreeNode* root) {
        if(root->left==NULL&&root->right==NULL)return true;
        if(root->left==NULL&&root->right!=NULL){
            if(root->val<root->right->val){
                return isValidBST(root->right);
            }
            
        }
        if(root->left!=NULL&&root->right==NULL){
            if(root->val>root->left->val){
                return isValidBST(root->left);
            }
        }
        if(root->left!=NULL&&root->right!=NULL){
            if(root->val>root->left->val&&root->val<root->right->val){
                return isValidBST(root->left)&&isValidBST(root->right);
            }
        }
        return false;

    }
};

忘记了右侧整棵树都要大于节点值，但是对于答案的递归法方法仍然有些不解，没太看懂，也就是转化成数组的形式好理解一些，记下关键的一点：

traversal(root->left);
        vec.push_back(root->val); // 将二叉搜索树转换为有序数组
        traversal(root->right);//中序遍历

 bool left = isValidBST(root->left);
        // 中序遍历，验证遍历的元素是不是从小到大
        if (maxVal < root->val) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);

也就是二叉树的中序遍历，这样就能将整颗二叉树从左中右的顺序记录下来，值得掌握。