前言
代码随想录算法训练营day20
一、Leetcode 654.最大二叉树
1.题目
给定一个不重复的整数数组 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. 1 <= nums.length <= 1000 2. 0 <= nums[i] <= 1000 3. nums 中的所有整数 互不相同
来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/maximum-binary-tree
2.解题思路
方法一：递归
思路与算法
最简单的方法是直接按照题目描述进行模拟。
我们用递归函数 construct(nums,left,right)construct(nums,left,right) 表示对数组 numsnums 中从 nums[left]nums[left] 到 nums[right]nums[right] 的元素构建一棵树。我们首先找到这一区间中的最大值，记为 numsnums 中从 nums[best]nums[best]，这样就确定了根节点的值。随后我们就可以进行递归：
1. 左子树为 construct(nums,left,best−1)construct(nums,left,best−1)； 2. 3. 右子树为 construct(nums,best+1,right)construct(nums,best+1,right)。
当递归到一个无效的区间(即 left>rightleft>right)时，便可以返回一棵空的树。
3.代码实现
```java class Solution { public TreeNode constructMaximumBinaryTree(int[] nums) { return construct(nums, 0, nums.length - 1); }
1. public TreeNode construct(int[] nums, int left, int right) { 2. if (left > right) { 3. return null; 4. } 5. int best = left; 6. for (int i = left + 1; i <= right; ++i) { 7. if (nums[i] > nums[best]) { 8. best = i; 9. } 10. } 11. TreeNode node = new TreeNode(nums[best]); 12. node.left = construct(nums, left, best - 1); 13. node.right = construct(nums, best + 1, right); 14. return node; 15. }
}
```
二、Leetcode 617.合并二叉树
1.题目
给你两棵二叉树： 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]
来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/merge-two-binary-trees
2.解题思路
方法一：深度优先搜索
可以使用深度优先搜索合并两个二叉树。从根节点开始同时遍历两个二叉树，并将对应的节点进行合并。
两个二叉树的对应节点可能存在以下三种情况，对于每种情况使用不同的合并方式。
1. 如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空； 2. 3. 如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点； 4. 5. 如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和，此时需要显性合并两个节点。
对一个节点进行合并之后，还要对该节点的左右子树分别进行合并。这是一个递归的过程。
3.代码实现
```java class Solution { public TreeNode mergeTrees(TreeNode t1, TreeNode t2) { if (t1 == null) { return t2; } if (t2 == null) { return t1; } TreeNode merged = new TreeNode(t1.val + t2.val); merged.left = mergeTrees(t1.left, t2.left); merged.right = mergeTrees(t1.right, t2.right); return merged; } } ```
三、Leetcode 700.二叉搜索树中的搜索
1.题目
给定二叉搜索树(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. 数中节点数在 [1, 5000] 范围内 2. 1 <= Node.val <= 107 3. root 是二叉搜索树 4. 1 <= val <= 107
来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/search-in-a-binary-search-tree
2.解题思路
方法一：递归
二叉搜索树满足如下性质：
1. 左子树所有节点的元素值均小于根的元素值； 2. 右子树所有节点的元素值均大于根的元素值。
据此可以得到如下算法：
1. 若 rootroot 为空则返回空节点； 2. 若 val=root.valval=root.val，则返回 rootroot； 3. 若 val<root.valval<root.val，递归左子树； 4. 若 val>root.valval>root.val，递归右子树。
3.代码实现
```java class Solution { public TreeNode searchBST(TreeNode root, int val) { if (root == null) { return null; } if (val == root.val) { return root; } return searchBST(val < root.val ? root.left : root.right, val); } } ```
1.题目
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
1. 节点的左子树只包含 小于 当前节点的数。 2. 节点的右子树只包含 大于 当前节点的数。 3. 所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
输入：root = [2,1,3] 输出：true
示例 2：
输入：root = [5,1,4,null,null,3,6] 输出：false 解释：根节点的值是 5 ，但是右子节点的值是 4 。
提示：
1. 树中节点数目范围在[1, 104] 内 2. -231 <= Node.val <= 231 - 1
来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/validate-binary-search-tree
2.解题思路
方法一: 递归
思路和算法
要解决这道题首先我们要了解二叉搜索树有什么性质可以给我们利用，由题目给出的信息我们可以知道：如果该二叉树的左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；它的左右子树也为二叉搜索树。
这启示我们设计一个递归函数 helper(root, lower, upper) 来递归判断，函数表示考虑以 root 为根的子树，判断子树中所有节点的值是否都在 (l,r)(l,r) 的范围内(注意是开区间)。如果 root 节点的值 val 不在 (l,r)(l,r) 的范围内说明不满足条件直接返回，否则我们要继续递归调用检查它的左右子树是否满足，如果都满足才说明这是一棵二叉搜索树。
那么根据二叉搜索树的性质，在递归调用左子树时，我们需要把上界 upper 改为 root.val，即调用 helper(root.left, lower, root.val)，因为左子树里所有节点的值均小于它的根节点的值。同理递归调用右子树时，我们需要把下界 lower 改为 root.val，即调用 helper(root.right, root.val, upper)。
函数递归调用的入口为 helper(root, -inf, +inf)， inf 表示一个无穷大的值。
3.代码实现
```java class Solution { public boolean isValidBST(TreeNode root) { return isValidBST(root, Long.MINVALUE, Long.MAXVALUE); }
1. public boolean isValidBST(TreeNode node, long lower, long upper) { 2. if (node == null) { 3. return true; 4. } 5. if (node.val <= lower || node.val >= upper) { 6. return false; 7. } 8. return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper); 9. }
}
```
