代码随想录day20

654.最大二叉树 

最重要的是：构造二叉树类的题目一定要用前序遍历，一定是先构造出根节点再构造出左子树和右子树。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector& nums) {
        if(nums.size()==1) return new TreeNode(nums[0]);//只有一个元素说明是叶子结点，返回
        int index=0;//因为之后要分割左右区间所以要记录下标
        int maxval=0;//因为所有的值都≥0，所以初始值为0
        for(int i=0;imaxval){
                index=i;
                maxval=nums[i];
            }
        }
        //找到最大值后先创建根节点
        TreeNode* root=new TreeNode(maxval);
        if(index>0){//因为有一个元素的时候就返回了所以要保证传入的数组至少有一个元素，递归才有意义
            vector newvec(nums.begin(),nums.begin()+index);
            root->left=constructMaximumBinaryTree(newvec);
        }
        if(index newvec(nums.begin()+index+1,nums.end());
            root->right=constructMaximumBinaryTree(newvec);
        }
        return root;
    }
};

 617.合并二叉树 

直接在tree1上进行构造新的二叉树。本题用前中后序都可以，只是用前序遍历更容易理解。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {//返回构造好的二叉树的根节点
        if(root1==NULL) return root2;
        if(root2==NULL) return root1;
        //以下就是都不为空的情况
        root1->val+=root2->val;//先处理根节点
        //之后递归处理左右子树
        root1->left=mergeTrees(root1->left,root2->left);
        root1->right=mergeTrees(root1->right,root2->right);
        return root1;
    }
};

700.二叉搜索树中的搜索 

递归法：（不涉及什么前中后序）

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==NULL||root->val==val) return root;
        TreeNode* result;
        if(valval) result=searchBST(root->left,val);
        if(val>root->val) result=searchBST(root->right,val);
        return result; 
    }
};

迭代法：大部分二叉树的题目的迭代法都非常复杂，但本题的迭代法很简单，就是如果valval就往左移动，大于就向右移动，等于就返回，最后如果都没有找到的话就返回NULL。

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root){
            if(valval) root=root->left;
            else if(val>root->val) root=root->right;
            else return root;
        }
        return NULL;
    }
};

98.验证二叉搜索树（要想到中序遍历）

递归法：先中序遍历二叉树，将结果放入数组中，然后验证数组是否为升序排列即可。

class Solution {
public:
    vector res;
    void traversal(TreeNode* node){
        if(node==NULL) return;
        traversal(node->left);
        res.push_back(node->val);
        traversal(node->right);
    }
    bool isValidBST(TreeNode* root) {
        res.clear();
        traversal(root);
        for(int i=1;i

以上是转换成数组再进行判断，我们可以直接在遍历的过程中进行比较。因为后台测试数据有int的最小值（上来就会return false），所以我们要把初始值初始化成long long的最小值LONT_MIN,然后进行比较。

class Solution {
public:
    long long maxval=LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root==NULL) return true;
        bool left=isValidBST(root->left);
        if(root->val>maxval){
            maxval=root->val;
        }else{
            return false;
        }
        bool right=isValidBST(root->right);
        return left&&right;
    }
};

那如果测试数据有long long的最小值呢，所以我们可以避免初始化最小值，直接取最左面的数值进行比较。

class Solution {
public:
    TreeNode* pre=NULL;
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        //TreeNode* pre=NULL;
        bool left=isValidBST(root->left);
        if(pre&&pre->val>=root->val) return false;
        else pre=root;
        bool right=isValidBST(root->right);
        return left&&right;
    }
};

错因：pre指针的初始化应该写在外面，不然每次向下递归都会被重新初始化为NULL。