代码随想录算法训练营第十八天|98.验证二叉搜索树， 654.最大二叉树

98.验证二叉搜索树

这题的最主要思路就是如果是二叉搜索树的话，中序遍历一定是从小到大的有序遍历（想不到这题就不好写）

先从迭代来看，先中序遍历得到数组，数组是从小到大排序的话证明是二叉搜索树。

class Solution {
public:
vector<int>v1;
    void diedai(TreeNode* root)
    {
        if(root==nullptr)return;
        diedai(root->left);
        v1.push_back(root->val);
        diedai(root->right);

    }

    bool isValidBST(TreeNode* root) {
        v1.clear();
        diedai(root);
        for(int i=0;i<v1.size()-1;i++)
        {
            if(v1[i]>=v1[i+1])
            return false;

        }
        return true;

    }
};

递归也是相同的逻辑，中序的话要从小到大。

确定从小到大需要一个基准值，每次递归时候都需要更新和比较这个值。

class Solution {
public:
    long long val=LONG_MIN;
    bool digui(TreeNode* root)
    {
        if(root==nullptr)return true;

        bool left=digui(root->left);

        if(root->val>val)
        val=root->val;//加上return true？
        else 
        return false;

        bool right=digui(root->right);

        return left&&right;




    }
    bool isValidBST(TreeNode* root) {
        return digui(root);
    }
};

关于这个代码还有需要讨论的地方

关于递归函数的返回值，代码随想录说的很好：

只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值

第二就是val=root->val;//加上return true？，真的能加吗？

肯定不能加的，返回true需要的条件更为苛刻，当前的节点root需要返回true的话还需要digui(root->right)的信息，现在只用到了digui(root->left)的信息，所以这里不能返回true。

 654.最大二叉树 

与昨天的思路一样，都是分割数组。分割点就是数组中的最大值。

class Solution {
public:
    TreeNode* digui(vector<int>& nums)
    {
        if(nums.size()==0)return nullptr;
        int maxValue = *max_element(nums.begin(),nums.end());
        TreeNode* root=new TreeNode(maxValue);
        int i;
        for(i=0;i<nums.size();i++)
        {
            if(nums[i]==maxValue)break;
        }
        vector<int>v1(nums.begin(),nums.begin()+i);
        vector<int>v2(nums.begin()+i+1,nums.end());
        root->left=digui(v1);
        root->right=digui(v2);
        return root;



    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==0)return nullptr;

        return digui(nums);

    }
};

617.合并二叉树

同时对两个二叉树进行相同的递归就行，值得注意的是，当root1为空时，直接返回root2就行，这样可以简化计算。

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

    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        return digui(root1,root2);

    }
};

700.二叉搜索树中的搜索

二叉搜索树独有的排序特性使迭代和递归都变得非常简单。

当寻找的值大于当前节点的值时，就去当前节点的右子树寻找，反之就去左子树寻找

递归法：

class Solution {
public:
    TreeNode*diedai(TreeNode* root, int val)
    {
        TreeNode*roo;
        if(root==nullptr||root->val==val)return root;//如果节点都空了还没找到，证明
//已经遍历完了但是没有对应的节点，所以返回r哦哦听，也就是null
        if(root->val>val)roo=diedai(root->left,val);
        if(root->val<val)roo=diedai(root->right,val);
        return roo;

    }
    TreeNode* searchBST(TreeNode* root, int val) {
        return diedai(root,val);
    }
};

迭代法

class Solution {
public:


    
    TreeNode* searchBST(TreeNode* root, int val) {
        
        while(root!=nullptr)
        {
            if(root->val==val)return root;
            else if(root->val<val)root=root->right;
            else root=root->left;



        }
        return root;
    }
};