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

654.最大二叉树

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

• 二叉树的根是数组中的最大元素。
• 左子树是通过数组中最大值左边部分构造出的最大二叉树。
• 右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

反是构造二叉树的题目都要使用前序遍历。先构建中结点，再构建左子树，右子树。

返回值：返回类型，一个结点，输入类型，一个数组。

终止条件：如果我们的数组的大小==1，到叶子节点了，可以返回了。说明根节点是叶子节点。

单层递归：

找到数组的最大值，最大值的下标，作为分割点。中：构建这个节点的左子树和右子树；左：分割得到左数组，它的大小至少大于等于1；右：分割得到右数组，它的大小大于等于1。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==1){
            return new TreeNode(nums[0]);
        }
        int maxval = 0;
        int index = 0;
        for(int i=0; i<nums.size(); i++){
            if(nums[i]>maxval){
                maxval = nums[i];
                index = i;
            }
        }
        TreeNode* root = new TreeNode(maxval);
        if(index>0){
            vector<int> newnums(nums.begin(), nums.begin()+index);
            root->left = constructMaximumBinaryTree(newnums);
        }
        if(index<nums.size()-1){ //index的右边至少有一个值！
            vector<int> newnums(nums.begin()+index+1, nums.end());
            root->right = constructMaximumBinaryTree(newnums);
        }
        return root;
    }
};

617.合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

1. 参数：传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

2. 终止条件：如果t1 == NULL 了，两个树合并就应该是 t2 了，反之亦然。（包括都为NULL)

3. 递归条件：中：两棵树的元素加到一起，左：合并 t1左子树 t2左子树之后的左子树，右：t1右子树 t2右子树之后的右子树。

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

700.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

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

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

1. 传参：输入树的根结点和要找的数，输出搜索值所在的结点。

2. 终止条件：如果root为空或者找到节点了，则返回

3. 选择单层递归：如果root的值大于目标，则搜索左子树，如果小于目标，则搜索右子树。

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 root;
    }
};

98.验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

中序遍历下，输出的二叉搜索树的数值是有序数组。

class Solution {
public:
    vector<int> vec;
    void tranversal(TreeNode* root, vector<int>& vec){
        if(root==NULL) return;
        if(root->left) tranversal(root->left, vec);
        vec.push_back(root->val);
        if(root->right) tranversal(root->right, vec);
    }
    bool isValidBST(TreeNode* root) {
        tranversal(root, vec);
        for(int i=1; i<vec.size(); i++){
            if(vec[i]<=vec[i-1]){
                return false;
            }
        }
        return true;
    }
};

使用迭代法：

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        while(cur!=NULL || !st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                st.pop();
                if(pre!=NULL && pre->val>=cur->val) return false;
                pre = cur;
                cur = cur->right;
            }
        }
        return true;
    }
};