654.最大二叉树

题目：654. 最大二叉树

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size() == 0){
            return nullptr;
        }
        int ans = -1;
        int ind;
        for(int i = 0;i < nums.size(); ++i){
            if(nums[i] > ans){
                ans = nums[i];
                ind = i;
            }
        }
        TreeNode* root = new TreeNode(ans);
        vector<int> nums_left(nums.begin(), nums.begin() + ind);
        vector<int> nums_right(nums.begin() + ind + 1, nums.end());
        root->left = constructMaximumBinaryTree(nums_left);
        root->right = constructMaximumBinaryTree(nums_right);
        return root;
    }
};

617.合并二叉树

题目：617. 合并二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
       
        if(root1 == nullptr && root2 == nullptr) return nullptr;
        else if(root1 == nullptr && root2 != nullptr){
            return root2;
        }else if(root1 != nullptr && root2 == nullptr){

            return root1;
        }else{
            TreeNode* root = new TreeNode(0);
            int ans = 0;
            ans += root1->val;
            ans += root2->val;
            root->val = ans;
            root->left =  mergeTrees(root1->left, root2->left);
            root->right =  mergeTrees(root1->right, root2->right);
            return root;
        } 
    }
};

700.二叉搜索树中的搜索

题目：700. 二叉搜索树中的搜索

/层序遍历
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* ans;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int size = q.size();
            TreeNode* cur = q.front();
            q.pop();
            while(size--){
                if(cur->val == val){
                    ans = cur;
                    return ans;
                }
                if(cur->val > val){
                    if(cur->left) q.push(cur->left);
                }else{
                    if(cur->right) q.push(cur->right);
                }
                
                
            }
        }
        return nullptr;
    }
};


//递归法
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == nullptr) return nullptr;
        if(root->val > val) {
            return searchBST(root->left,val);
        }else if(root->val < val){
            return searchBST(root->right,val);
        }else{
            return root;
        }
        return nullptr;
    }
};

98.验证二叉搜索树

题目：98. 验证二叉搜索树

//中序遍历下，输出的二叉搜索树节点的数值是有序序列。
class Solution {
public:
    void midtrval(TreeNode* root, vector<int>& v){
        if(root == nullptr) return;
        midtrval(root->left,v);
        v.push_back(root->val);
        midtrval(root->right,v);
        return;
    }
    bool isValidBST(TreeNode* root) {
        vector<int> v;
        midtrval(root,v);
        for(int i = 1; i < v.size(); ++i){
            if(v[i] <= v[i - 1]) return false;
        }
        return true;
    }
};

总结

题型：二叉树的迭代，二叉搜索树

技巧：注意二叉树，二叉搜索树的性质，二叉搜索树的有序性。