代码随想录算法训练营day20 | 题目654、题目998、题目617、题目700、题目98
题目一描述
给定一个不重复的整数数组 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 的节点。
- 空数组，无子节点。
- [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
示例 2：
输入：nums = [3,2,1]
输出：[3,null,2,null,1]
提示：
1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同
解题思路
找到最大值然后划分区间，递归构建即可。
也可以用模拟的思想，类似第998题。
代码实现
方法一：
class Solution {
public TreeNode constructMaximumBinaryTree(int[] nums) {
return build(nums, 0, nums.length);
}
private TreeNode build(int[] nums, int start, int end) {
if (start >= end) {
return null;
}
int value = -1;
int index = -1;
for (int i = start; i < end; i++) {
if (nums[i] > value) {
value = nums[i];
index = i;
}
}
TreeNode head = new TreeNode(value);
head.left = build(nums, start, index);
head.right = build(nums, index + 1, end);
return head;
}
}
方法二：
class Solution {
public TreeNode constructMaximumBinaryTree(int[] nums) {
TreeNode head = new TreeNode(nums[0]);
for (int i = 1; i < nums.length; i++) {
head = build(head, nums[i]);
}
return head;
}
private TreeNode build(TreeNode root, int val) {
if (root == null) {
return new TreeNode(val);
}
if (val < root.val) {
root.right = build(root.right, val);
return root;
}
if (val > root.val) {
TreeNode head = new TreeNode(val);
head.left = root;
return head;
}
return root;
}
}
题目二描述
最大树 定义：一棵树，并满足：其中每个节点的值都大于其子树中的任何其他值。
给你最大树的根节点 root 和一个整数 val 。
就像 之前的问题 那样，给定的树是利用 Construct(a) 例程从列表 a（root = Construct(a)）递归地构建的：
如果 a 为空，返回 null 。
否则，令 a[i] 作为 a 的最大元素。创建一个值为 a[i] 的根节点 root 。
root 的左子树将被构建为 Construct([a[0], a[1], ..., a[i - 1]]) 。
root 的右子树将被构建为 Construct([a[i + 1], a[i + 2], ..., a[a.length - 1]]) 。
返回 root 。
请注意，题目没有直接给出 a ，只是给出一个根节点 root = Construct(a) 。
假设 b 是 a 的副本，并在末尾附加值 val。题目数据保证 b 中的值互不相同。
返回 Construct(b) 。
示例 1：
输入：root = [4,1,3,null,null,2], val = 5
输出：[5,4,null,1,3,null,null,2]
解释：a = [1,4,2,3], b = [1,4,2,3,5]
示例 2：
输入：root = [5,2,4,null,1], val = 3
输出：[5,2,4,null,1,null,3]
解释：a = [2,1,5,4], b = [2,1,5,4,3]
示例 3：
输入：root = [5,2,3,null,1], val = 4
输出：[5,2,4,null,1,3]
解释：a = [2,1,5,3], b = [2,1,5,3,4]
提示：
树中节点数目在范围 [1, 100] 内
1 <= Node.val <= 100
树中的所有值 互不相同
1 <= val <= 100
解题思路
模拟题，分情况讨论递归即可。
代码实现
方法一：
class Solution {
public TreeNode insertIntoMaxTree(TreeNode root, int val) {
if(root == null){
return new TreeNode(val);
}
if(val < root.val){
root.right = insertIntoMaxTree(root.right, val);
return root;
}
if(val > root.val){
TreeNode head = new TreeNode(val);
head.left = root;
return head;
}
return root;
}
}
题目三描述
给你两棵二叉树： 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] 内
-10^4 <= Node.val <= 10^4
解题思路
dfs同时递归即可。
代码实现
方法一：
class Solution {
public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
if (root1 == null && root2 == null) {
return null;
}
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;
}
}
题目四描述
给定二叉搜索树（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
解题思路
二叉搜索树，就是中序遍历
子树，就是后序遍历
代码实现
方法一：
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if (root == null) {
return null;
}
if (val < root.val) {
return searchBST(root.left, val);
} else if (val > root.val) {
return searchBST(root.right, val);
} else {
return root;
}
}
}
题目五描述
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
输入：root = [2,1,3]
输出：true
示例 2：
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。
提示：
树中节点数目范围在[1, 10^4] 内
-2^31 <= Node.val <= 2^31 - 1
解题思路
验证的本质是，判断这个二叉搜索树的中序遍历是不是单调递增的，所以使用中序遍历，每次取得上一个结点的值来做判断。
使用数字来保存有可能会导致范围溢出，所以改用结点保存更好一些，第一次赋值一定是第一个结点，之后每次判断是否为空即可。
代码实现
方法一：
class Solution {
long leftMax = Long.MIN_VALUE; // 使用int可能会取到最小值，这里用long
public boolean isValidBST(TreeNode root) {
boolean res1 = true;
boolean res2 = true;
if (root.left != null) {
res1 = isValidBST(root.left);
}
if (root.val <= leftMax) {
return false;
}
leftMax = Math.max(root.val, leftMax);
if (root.right != null) {
res2 = isValidBST(root.right);
}
return res1 && res2;
}
}
方法二：
class Solution {
TreeNode preNode;
public boolean isValidBST(TreeNode root) {
boolean res1 = true;
boolean res2 = true;
if (root.left != null) {
res1 = isValidBST(root.left);
}
if (preNode != null && root.val <= preNode.val) {
return false;
}
preNode = root;
if (root.right != null) {
res2 = isValidBST(root.right);
}
return res1 && res2;
}
}
技巧总结
学会取Long的最小值。
