Day20(Day19摆烂).最大二叉树.合并二叉树.BST二叉搜索树中的搜索.验证二叉搜索树

成年人的世界，似乎只有赚到足够的钱，才能过上简单、安逸、自由的生活，才能让自己活得更有底气些。所以，多一些努力吧，少点功夫矫情。

654.最大二叉树

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);//初始化一个节点并且赋值为0;
        if(nums.size()==1) //说明这个数组只有一个
        { 
            node->val=nums[0];//让node的值为数组第一个，并返回
            return node;
        }
        int max = 0;//存最大值！
        int foot = 0;//存下标 ps:以后要用index表示下标，foot太low了
        for(int  i = 0;i <nums.size();i++)
        {
            if(nums[i]>max)
            {
                max=nums[i];
                foot=i;
            }
        }
        node->val=max;//让max为node的值
        if(foot>0)//左子树
        {
            vector<int> leftVec(nums.begin(),nums.begin()+foot);//左闭右开区间
            node->left=constructMaximumBinaryTree(leftVec);
        }
        if(foot<nums.size()-1)//右子树
        {
            vector<int> rightVec(nums.begin()+foot+1,nums.end());//区间同上
            node->right=constructMaximumBinaryTree(rightVec);
        }

        return node;
    }
};

617. 合并二叉树(前中后序都是可以的)

中序打个样！

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==NULL) return root2;//如果一方为空，则返回另一方，另一方为空也没有关系返回的依旧是空
        if(root2==NULL) return root1;
        //重复利用树1
        root1->val+=root2->val;//合并,在此处root1的值已经改变
        root1->left=mergeTrees(root1->left,root2->left);//递归
        root1->right=mergeTrees(root1->right,root2->right);
        return root1;
    }
};

700. 二叉搜索树中的搜索（BST）

首先理解二叉搜索树的概念
（来自百度资料）

二叉查找树 （Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的 二叉树 ：
若它的左子树不空，则左子树上所有结点的值均小于它的 根结点 的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

简单来说
左子树的值小于根，右子树的值大于根（如果不为空的话）
1.迭代法
利用BST的特性来求解

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root!=NULL)//直到遇到空节点时返回，例如BST为[] 或 搜索的值不存在，跳出循环，返回NULL
        {
            if(val>root->val)//说明要在BST的左子树查找
                root= root->right;
            else if(val<root->val)//说明要在BST的右子树查找.注意else
                root= root->left;
            else return root;//等于情况
        }
        return NULL;
    }
};

2.递归法

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == NULL || root->val == val) return root;//空返回空，值返回值
        TreeNode* temp; //用来保存下面递归返回的子树
        if(val>root->val) temp=searchBST(root->right, val);
        else if(val<root->val) temp=searchBST(root->left, val);
        return temp;
    }

98.验证二叉搜索树

根据BST 中序序列 左 中 右 的特性（单调递增）来思考
BST中不能有相同的元素！
1.数组法

class Solution {
private:
    vector<int> room;
     void putArr(TreeNode* root)//无返回值,让BST以中序数组存入vector中
    {
         if(root == NULL) return;//返回上一层
            putArr(root->left);//左
            room.push_back(root->val);//中
            putArr(root->right);//右
    }
public:
    bool isValidBST(TreeNode* root) {
       room.clear();
       putArr(root);//存入
       for(int i=1;i<room.size();i++)
       {
           if(room[i]<=room[i-1])//“=”意思不能出现相同元素
            return false;
       }
       return true;
    }
};

2.双值判断
思路：其实还是中序 左 根 右 的比较

class Solution {
public:
    long long cmp = LONG_MIN;//外部放最小值
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        //long long cmp=LONG_MIN;//long long类型最值学习！!!这里放最小值为错，最小值一直未变！
        //改为静态static 每递归一次，又会重新定义为最小值，所以要在最外层定义
        bool leftT = isValidBST(root->left);//左子树判断 （定义left来保存其真假，下同）
        if(root->val> cmp) cmp = root->val;//主体比较思路
        else return false;
        bool rightT=isValidBST(root->right);//右子树判断
        return leftT&&rightT;//如果两子树都符合BTS的定义，则返回真，如果至少有一侧不满足，返回假
        
    }
};