第六章 二叉树 part05

最大二叉树

题目描述

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

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 ​nums​ 构建的 **最大二叉树 **。

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

解题思路

整体思路： 利用数组中的最大值作为根节点，逐步构建出最大二叉树。每次递归都会基于根节点将数组分割为两部分，分别构建左右子树，直到数组范围为空。

核心代码说明：

1. 递归函数的参数和返回值：traversal 函数接受一个数组 nums 和两个索引 left 和 right，表示当前处理的数组范围。返回值是构建的子树的根节点。
2. 递归函数的终止条件：如果左边界 left 大于或等于右边界 right，表示当前处理的数组范围为空，返回 nullptr
3. 递归函数的单层逻辑：首先在当前数组范围内找到最大值及其索引。然后创建根节点，其值为最大值。接着递归地构建左子树（数组范围为 [left, maxValueIndex)）和右子树（数组范围为 [maxValueIndex + 1, right)）。最后返回当前子树的根节点。

代码实现

测试地址：https://leetcode.cn/problems/maximum-binary-tree/

class Solution {
private:
    // 递归函数：根据给定的数组构建最大二叉树
    TreeNode* traversal(vector<int> nums, int left, int right) {
        // 终止条件：如果左边界大于或等于右边界，返回nullptr
        if (left >= right)
            return nullptr;

        // 找到数组中的最大值及其索引
        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());
    }
};

合并二叉树

题目描述

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

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例 2：

输入：root1 = [1], root2 = [1,2]
输出：[2,2]

解题思路

整体思路： 将两个二叉树的对应节点值相加，并递归地处理它们的左右子树，从而实现两个二叉树的合并。每次递归都会处理两个树的对应节点，直到所有节点都被处理完毕。

核心代码说明：

核心思路：

1. 递归函数的参数和返回值：mergeTrees 函数接受两个二叉树的根节点 root1 和 root2。返回值是合并后的二叉树的根节点。
2. 递归函数的终止条件：如果 root1 为 nullptr，则返回 root2；如果 root2 为 nullptr，则返回 root1。这表示如果其中一个树为空，则直接返回另一个树的节点。
3. 递归函数的单层逻辑：首先检查两个树的根节点是否有一个为空，如果是，则返回非空的那个节点。然后，将 root2 的值加到 root1 上，表示合并两个节点的值。接着，递归地合并左子树和右子树，分别将结果赋值给 root1 的左子节点和右子节点。最后，返回 root1，即合并后的树的根节点。

代码实现

测试地址：https://leetcode.cn/problems/merge-two-binary-trees/

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;
    }
};

二叉搜索树中的搜索

题目描述

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

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

示例 2:

输入：root = [4,2,7,1,3], val = 5
输出：[]

解题思路

整体思路： 根据二叉搜索树的性质（小的值在左边，大的值在右边）查找给定值的节点。每次递归都会根据当前节点的值与目标值的比较结果，决定是继续在左子树还是右子树中查找，直到找到目标值或遍历完所有节点。

递归实现说明：

1. 递归函数的参数和返回值：searchBST 函数接受一个二叉搜索树的根节点 root 和一个整数 val。返回值是找到的节点，如果未找到则返回 nullptr。
2. 递归函数的终止条件：如果当前节点 root 为 nullptr 或者当前节点的值 root->val 等于目标值 val，则返回当前节点。
3. 递归函数的单层逻辑：根据二叉搜索树的性质，如果当前节点的值大于目标值，则递归地在左子树中查找；如果当前节点的值小于目标值，则递归地在右子树中查找。如果找到目标值，返回对应的节点；如果未找到，最终会返回 nullptr。

代码实现

测试地址：https://leetcode.cn/problems/search-in-a-binary-search-tree/

递归写法：

class Solution {
public:
    TreeNode* searchBST(TreeNode *root, int val) {
        // 终止条件：如果当前节点为空或当前节点的值等于目标值，返回当前节点
        if (root == nullptr || root->val == val)
            return root;

        // 如果当前节点的值大于目标值，递归查找左子树
        if (root->val > val)
            return searchBST(root->left, val);

        // 如果当前节点的值小于目标值，递归查找右子树
        if (root->val < val)
            return searchBST(root->right, val);

        // 默认返回 nullptr
        return nullptr;
    }
};

迭代法写法：

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

验证二叉搜索树

题目描述

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

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

• 节点的左子树只包含 小于 当前节点的数。
• 节点的右子树只包含 大于 当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

解题思路

整体思路： 中序遍历二叉树，并检查每个节点是否满足二叉搜索树的性质（即每个节点的值都大于其左子树的所有节点的值，且小于其右子树的所有节点的值）。通过记录前一个节点并比较其值，确保了中序遍历的顺序是严格递增的。

递归流程说明：

1. 递归函数的参数和返回值：isValidBST 函数接受一个二叉树的根节点 root。返回值是一个布尔值，表示该二叉树是否是有效的二叉搜索树。
2. 递归函数的终止条件：如果当前节点 root 为 NULL，则返回 true，表示空子树是有效的二叉搜索树。
3. 递归函数的单层逻辑：首先递归检查左子树，然后检查当前节点是否大于前一个节点（使用 pre 记录前一个节点）。如果当前节点不大于前一个节点，则返回 false。接着递归检查右子树。最后，返回左子树和右子树的结果的逻辑与，即只有当左子树和右子树都是有效的二叉搜索树且当前节点满足二叉搜索树的性质时，整个树才是有效的二叉搜索树。

代码实现

测试地址：https://leetcode.cn/problems/validate-binary-search-tree/

class Solution {
public:
    TreeNode* pre = NULL; // 用来记录前一个节点

    bool isValidBST(TreeNode* root) {
        // 终止条件：如果当前节点为空，返回true
        if (root == NULL) return true;

        // 递归检查左子树
        bool left = isValidBST(root->left);

        // 检查当前节点是否大于前一个节点
        if (pre != NULL && pre->val >= root->val) return false;
        pre = root; // 记录前一个节点

        // 递归检查右子树
        bool right = isValidBST(root->right);

        // 返回左子树和右子树的结果的逻辑与
        return left && right;
    }
};