第十七天 第六章 二叉树 part05 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

654.最大二叉树  

这里的关键是先要在数组里找到切分左右节点的分割点的值和下标。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        if (nums.size() == 1) {
            node->val = nums[0];
            return node;
        }
        int maxValue = 0;
        int maxValueIndex = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        node->val = maxValue;
        if (maxValueIndex > 0) {
            vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);
            node->left = constructMaximumBinaryTree(newVec);
        }
        if (maxValueIndex < (nums.size() - 1)) {
            vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

617.合并二叉树  

刚开始做思路有问题，还分了不同的情况去处理。其实就创建一个根节点，将两个二叉树对应节点相加减。

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

700.二叉搜索树中的搜索  

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

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

我们在遍历时，如果节点值大于目标值，则说明我们要找的节点再左子树上，反之一样。

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

98.验证二叉搜索树 

1.不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。(我的做法)

2.样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。

此时可以初始化比较元素为longlong的最小值。

方法一，将所有节点按照中序放入数组，然后判定数组是否为升序。

方法二：直接判断。

class Solution {
public:
    long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
    bool isValidBST(TreeNode* root) {
        if (root == NULL) 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;
    }
};