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

代码随想录算法训练营第十六天 | 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 = 0index = 0for i in range(len(nums)):      # 找到数组中的最大值以及其下标if nums[i] > maxNum:maxNum = nums[i]index = inode.val = maxNumif 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 NonemaxVal = 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 root2if not root2:return root1root1.val += root2.valroot1.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 rootif 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 Falseself.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);
}