代码随想录算法训练营第十七天|LeetCode654.最大二叉树、LeetCode617.合并二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode98.验证二叉搜索树

目录

前言

一、LeetCode654.最大二叉树

题目链接：

代码：

二、LeetCode617.合并二叉树

题目链接：

代码：

三、LeetCode700.二叉搜索树中的搜索

题目链接：

代码：

四、LeetCode98.验证二叉搜索树

题目链接：

代码：

---

前言

LeetCode654.最大二叉树

文章讲解：LeetCode654.最大二叉树

视频讲解：LeetCode：654.最大二叉树_哔哩哔哩_bilibili

LeetCode617.合并二叉树

文章讲解：LeetCode617.合并二叉树

视频讲解：LeetCode：617.合并二叉树_哔哩哔哩_bilibili

LeetCode700.二叉搜索树中的搜索

文章讲解：LeetCode700.二叉搜索树中的搜索

视频讲解：LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

LeetCode98.验证二叉搜索树

文章讲解：LeetCode98.验证二叉搜索树

视频讲解：LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

---

一、LeetCode654.最大二叉树

题目链接：

654. 最大二叉树 - 力扣（LeetCode）

代码：

/**
 * 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) {
        if(nums.size() == 0)
            return nullptr;
        int index = 0;
        int maxNum = INT32_MIN;
        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] > maxNum)
            {
                maxNum = nums[i];
                index = i;
            }
        }

        TreeNode* root = new TreeNode(maxNum);
        if(nums.size() == 1)
        {
            return root;
        }

        vector<int> leftTree(nums.begin(), nums.begin() + index);
        vector<int> rightTree(nums.begin() + index + 1, nums.end());
        
        root->left = constructMaximumBinaryTree(leftTree);
        root->right = constructMaximumBinaryTree(rightTree);

        return root;
    }
};

二、LeetCode617.合并二叉树

题目链接：

617. 合并二叉树 - 力扣（LeetCode）

代码：

/**
 * 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) {
        if(root1 == nullptr) return root2;
        if(root2 == nullptr) return root1;

        TreeNode* root = new TreeNode(root1->val + root2->val);

        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);
        return root;   
    }
};

三、LeetCode700.二叉搜索树中的搜索

题目链接：

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

代码：

/**
 * 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) {
        while(root)
        {
            if(root->val == val)
                return root;
            
            else if(root->val > val)
            {
                root = root->left;
            }
            else
            {
                root = root->right;
            }
        }
        return nullptr;
    }
};

四、LeetCode98.验证二叉搜索树

题目链接：

98. 验证二叉搜索树 - 力扣（LeetCode）

代码：

/**
 * 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* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;

        bool left = isValidBST(root->left);
        if(pre && pre->val >= root->val)
            return false;
        pre = root;
        bool right = isValidBST(root->right);

        return left && right;
    }
};