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

文章目录

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

1 LeetCode 654.最大二叉树

题目链接：https://leetcode.cn/problems/maximum-binary-tree/

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

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

返回 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 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

这道题目我们需要使用递归法的前序遍历实现，因为我们需要首先确定根节点，跟之前的根据中序遍历和后序遍历构造二叉树类似，遍历题目所给数组找到最大值，然后赋值给根节点，然后从根节点划分左右子树区间，如果左右区别都存在，那么我们就递归的对左右区别再次调用递归函数进行构造，递归函数的终止条件就是当区间的长度等于1的时候结束，我们不用判断空节点的情况，因为题目给的条件就是数组长度是大于等于1的。

（1）Python版本代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 1:  # 递归终止条件
            return TreeNode(nums[0])
        node = TreeNode(0)
        maxNum = 0
        index = 0
        for i in range(len(nums)):      # 找到数组中的最大值以及其下标
              if nums[i] > maxNum:
                  maxNum = nums[i]
                  index = i
        node.val = maxNum
        if index > 0:      # 最大值下标的左区间递归构造左子树
             newList = nums[:index]
             node.left = self.constructMaximumBinaryTree(newList)
        if index < len(nums) - 1:   # 最大值下标的右区间递归构造右子树
            newList = nums[index + 1:]
            node.right = self.constructMaximumBinaryTree(newList)
        return node

对于Python我们可以使用切片简化我们的代码。

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        if not nums:
            return None
        maxVal = max(nums)
        maxIndex = nums.index(maxVal)
        node = TreeNode(maxVal)
        node.left = self.constructMaximumBinaryTree(nums[:maxIndex])
        node.right = self.constructMaximumBinaryTree(nums[maxIndex+1:])
        return node

（2）C++版本代码

/**
 * 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;
        }
        // 找到数组中的最大值以及其下标
        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;
        // 最大值下标的左区间递归构造左子树
        if (maxValueIndex > 0) {
            vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);
            node->left = constructMaximumBinaryTree(newVec);
        }
        // 最大值下标的右区间递归构造右子树
        if (maxValueIndex < (nums.size() - 1)) {
            vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

2 LeetCode 617.合并二叉树

题目链接：https://leetcode.cn/problems/merge-two-binary-trees/description/

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

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

两棵树中的节点数目在范围 [0, 2000] 内
-104 <= Node.val <= 104

这道题目刚开始做我们会觉得很难，可能是因为题目太长导致的，但其中认真看一遍题目我们就会发现这题比较简单，给我们两棵二叉树所以我们需要同步进行遍历，如果遍历的当前节点为空，就填入另一棵树中对应的元素值，如果节点都存在就累加到一棵树上即可，最后递归的对左右子树进行操作就行，很明显我们使用的是前序遍历（其实这题哪种遍历都可以实现，但前序遍历更好理解）。

下面我们写出对应的代码。

（1）Python版本代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:
            return root2
        if not root2:
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

（2）C++版本代码

/**
 * 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* roott1, TreeNode* root2) {
        if (root1 == NULL) return root2; 
        if (root2 == NULL) return root1; 
        root1->val += root2->val;                             
        root1->left = mergeTrees(root1->left, root2->left);      
        root1->right = mergeTrees(root1->right, root2->right);   
        return root1;
    }
};

3 LeetCode 700.二叉搜索树中的搜索

题目链接：https://leetcode.cn/problems/search-in-a-binary-search-tree/

给定二叉搜索树（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, 5000] 范围内
1 <= Node.val <= 107
root 是二叉搜索树
1 <= val <= 107

这道题目还算简单，我们只需要根据二叉搜索树的特性去递归遍历即可，二叉搜索树节点值满足左小右大，而且根节点的左子树的所有值都比根节点小，右子树所有值都比根节点大，利用这个特性我们可以很快接近这道题目，递归遍历的终止条件就是遇见空节点（也就是遍历到叶子节点还没找到）或者找到了值与目标值相等的节点。

（1）Python版本代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root or root.val == val:
            return root
        if root.val > val:
            return self.searchBST(root.left, val)
        if root.val < val:
            return self.searchBST(root.right, val)

（2）C++版本代码

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

4 LeetCode 98.验证二叉搜索树

题目链接：https://leetcode.cn/problems/validate-binary-search-tree/description/

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

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

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

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

树中节点数目范围在[1, 104] 内
-231 <= Node.val <= 231 - 1

上一题我们知道了二叉搜索树的特性，本题也就是要利用这个特性来验证一棵二叉树是不是二叉搜索树，其中错误做法就是，遍历每个节点直接判断是否满足左<根<右，这样是不行的，正确做法就是使用中序遍历遍历二叉树，判断是否能是一个升序序列就行，这里就是体现了其特性（二叉搜索树和二叉排序树是一一样的）。

（1）Python版本代码

class Solution:
    def __init__(self):
        self.prev = float('-inf') 
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True      
        # 验证左子树
        if not self.isValidBST(root.left):
            return False      
        # 验证当前节点
        if root.val <= self.prev:
            return False
        self.prev = root.val
        # 验证右子树
        return self.isValidBST(root.right)

（2）C++版本代码

#include <iostream>
#include <limits>

class Solution {
private:
    long long prev = std::numeric_limits<long long>::min(); // 使用 long long 避免整数溢出
public:
    bool isValidBST(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }       
        // 验证左子树
        if (!isValidBST(root->left)) {
            return false;
        }       
        // 验证当前节点
        if (root->val <= prev) {
            return false;
        }
        prev = root->val;        
        // 验证右子树
        return isValidBST(root->right);
    }
};

    if (root == nullptr) {
        return true;
    }       
    // 验证左子树
    if (!isValidBST(root->left)) {
        return false;
    }       
    // 验证当前节点
    if (root->val <= prev) {
        return false;
    }
    prev = root->val;        
    // 验证右子树
    return isValidBST(root->right);
}