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

题目链接：leetcode 654.最大二叉树

文章讲解：代码随想录 654.最大二叉树讲解

视频讲解：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树

思路和解法

题目：
给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值 左边 的 子数组前缀上 构建左子树。
递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 nums 构建的 最大二叉树 。
想法：
思路：递归法构建，先找到当前数组中最大的数构建当前节点，同时记录下标，然后左侧的数组递归构建当前节点的左子树，右侧数组递归构建当前节点右子树。

/**
 * 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 {
private:
    // 在左闭右开区间[left, right)，构造二叉树
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right) return nullptr;

        // 分割点下标：maxValueIndex
        int maxValueIndex = left;
        for (int i = left + 1; i < right; ++i) {
            if (nums[i] > nums[maxValueIndex]) maxValueIndex = i;
        }

        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        // 左闭右开：[left, maxValueIndex)
        root->left = traversal(nums, left, maxValueIndex);

        // 左闭右开：[maxValueIndex + 1, right)
        root->right = traversal(nums, maxValueIndex + 1, right);

        return root;
    }
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

题目链接：leetcode 617.合并二叉树

文章讲解：代码随想录 617.合并二叉树讲解

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树

思路和解法

题目：
给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。
想法：
思路：同时操作两个二叉树，输入参数给了两个节点，同步处理即可，如果都有值就相加构建当前节点，如果有一个没有值就剩另一个节点，如果都没有值返回空即可。

/**
 * 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;
        root1 -> val += root2 -> val;
        //递归合并左子树和右子树
        root1 -> left = mergeTrees(root1 -> left, root2 -> left);
        root1 -> right = mergeTrees(root1 -> right, root2 -> right);
        return root1; 
    }
};

题目链接：leetcode 700.二叉搜索树中的搜索

文章讲解：代码随想录 700.二叉搜索树中的搜索讲解

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索

思路和解法

题目：
给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。
想法：
这道题目要掌握二叉搜索树的性质，就是左子树的值都小于当前节点值，右子树的值都大于当前节点的值。搜索就利用这个性质就不用全部遍历了。比较目标值和当前节点值大小。一直递归下去，直到遇到空节点说明没找到或者找到了直接返回，注意返回的是节点地址，可以用变量存下来，这样才会一步步传到第一次调用。

/**
 * 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) {
        if (root == nullptr || root -> val == val) return root;
        if (root -> val < val) {
            //往右子树搜索
            return searchBST(root -> right, val);
        }
        if (root -> val > val) {
            //往左子树搜索
            return searchBST(root -> left, val);
        }
        return nullptr;
    }
};

题目链接：leetcode 98.验证二叉搜索树

文章讲解：代码随想录 98.验证二叉搜索树讲解

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树

思路和解法

题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
想法：
递归法最简单，递归函数意义就是返回以传入节点为根节点的树是否是有效二叉搜索树，关键点在于要记录当前遍历的最大值，用这个判断当前节点是否大于左子树所有值，因为是中序遍历，左子树先遍历完，会存起来左子树最大值，然后可以判断当前节点，如果不满足直接返回false，注意相等也false，然后再遍历右子树，遍历完都有效就是true。

/**
 * 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:
    long long maxVal = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        //递归法 递归函数意义 返回以传入节点为根节点的树是否是有效二叉搜索树
        //终止条件 空树是有效的
        if (root == nullptr) 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;
    }
};