代码随想录算法训练营第20天|654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索|98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/2401_83080774/article/details/136637682

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

654.最大二叉树

又是构造二叉树，昨天大家刚刚做完中序后序确定二叉树，今天做这个应该会容易一些，先看视频，好好体会一下为什么构造二叉树都是前序遍历

题目链接/文章讲解：https://programmercarl.com/0654.%E6%9C%80%E5%A4%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html
视频讲解：https://www.bilibili.com/video/BV1MG411G7ox

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {//确定递归函数的参数和返回值
        //确定终止条件
        TreeNode* node=new TreeNode(0);
        if(nums.size()==1)
        {
            node->val=nums[0];
            return node;
        }
        
        //确定单层递归的逻辑
        //这里有三步工作

        //1.先要找到数组中最大的值和对应的下标， 最大的值构造根节点，下标用来下一步分割数组。
        //找到数组里面最大值和其下标
        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;

        //2.最大值所在的下标左区间 构造左子树
        //这里要判断maxValueIndex > 0，因为要保证左区间至少有一个数值。
        if(maxvalueindex>0)
        {
            vector<int> newVec(nums.begin(),nums.begin()+maxvalueindex);
            node->left=constructMaximumBinaryTree(newVec);
        }

        //最大值所在的下标右区间 构造右子树
        //判断maxValueIndex < (nums.size() - 1)，确保右区间至少有一个数值。
        if(maxvalueindex<nums.size()-1)
        {
            vector<int> newVec(nums.begin()+maxvalueindex+1,nums.end());
            node->right=constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

617.合并二叉树

这次是一起操作两个二叉树了，估计大家也没一起操作过两个二叉树，也不知道该如何一起操作，可以看视频先理解一下。优先掌握递归。

题目链接/文章讲解：https://programmercarl.com/0617.%E5%90%88%E5%B9%B6%E4%BA%8C%E5%8F%89%E6%A0%91.html
视频讲解：https://www.bilibili.com/video/BV1m14y1Y7JK

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        /*因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，

        如果t1 == NULL 了，两个树合并就应该是 t2 了
        （如果t2也为NULL也无所谓，合并之后就是NULL）。

        反过来如果t2 == NULL，那么两个数合并就是t1
        （如果t1也为NULL也无所谓，合并之后就是NULL）。
        */
        if(root1==NULL)return root2;//若t1为空，合并之后就是t2
        if(root2==NULL)return root1;//若t2为空，合并之后就是t1

        //确定单层递归的逻辑：
        root1->val+=root2->val;//那么单层递归中，就要把两棵树的元素加到一起。
        root1->left=mergeTrees(root1->left,root2->left);//接下来t1 的左子树是：合并 t1左子树 t2左子树之后的左子树。
        root1->right=mergeTrees(root1->right,root2->right);//t1 的右子树：是 合并 t1右子树 t2右子树之后的右子树。
        return root1;

    }
};

700.二叉搜索树中的搜索

递归和迭代都可以掌握以下，因为本题比较简单，了解一下二叉搜索树的特性

题目链接/文章讲解:
https://programmercarl.com/0700.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E6%90%9C%E7%B4%A2.html
视频讲解：https://www.bilibili.com/video/BV1wG411g7sF

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
        //确定递归函数的参数和返回值
        //递归函数的参数传入的就是根节点和要搜索的数值，
        //返回的就是以这个搜索数值所在的节点。
    TreeNode* searchBST(TreeNode* root, int val) {
        //确定终止条件
        //如果root为空，或者找到这个数值了，就返回root节点。
        if(root==NULL||root->val==val) return root;
        //确定单层递归的逻辑
        TreeNode* result=NULL;//定义一个结点
        if(root->val>val)result=searchBST(root->left,val);//因为时搜索二叉树，所以左是都小于结点，若value<node则左遍历
        if(root->val<val)result=searchBST(root->right,val);//因为时搜索二叉树，所以右是都大于结点，若value>node则右遍历
        return result;//返回最后结点
    }
};

98.验证二叉搜索树

遇到搜索树，一定想着中序遍历，这样才能利用上特性。

但本题是有陷阱的，可以自己先做一做，然后在看题解，看看自己是不是掉陷阱里了。这样理解的更深刻。

题目链接/文章讲解：https://programmercarl.com/0098.%E9%AA%8C%E8%AF%81%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html 视频讲解：https://www.bilibili.com/video/BV18P411n7Q4

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 /*   vector<int>vec;//此方法为遍历搜索二叉树，把结点的值依次放入到数组里，然后数组依次判断是否为从小到大

    void traversal(TreeNode* node)
    {
        if(node==NULL) return;
        traversal(node->left);
        vec.push_back(node->val);
        traversal(node->right);

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

        return true;
    }
    */
    TreeNode* pre=NULL;
    bool isValidBST(TreeNode* root) 
       {
        if(root==NULL) return true;//终止条件

        //中序遍历，一直更新pre，一旦发现pre >= root->val，
        //就返回false，注意元素相同时候也要返回false。
        bool left=isValidBST(root->left);
        if(pre!=NULL&&pre->val>=root->val)return false;
        pre=root;// 记录前一个节点

        
        bool right=isValidBST(root->right);//套用left的功能
        return left&&right;

       }
};