654. 最大二叉树
给定一个不重复的整数数组 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]
思路：
这是一道构建二叉树的题，先序遍历：先找出数组的最大值，然后递归的构造root.left和root.right
/**
* @param {number[]} nums
* @return {TreeNode}
*/
var constructMaximumBinaryTree = function(nums) {
if(nums.length === 0) return null
const rootValue = Math.max(...nums)
const rootIndex = nums.findIndex(i=>i === rootValue)
const root = new TreeNode(rootValue)
root.left = constructMaximumBinaryTree(nums.slice(0, rootIndex))
root.right = constructMaximumBinaryTree(nums.slice(rootIndex+1))
return root
};
617. 合并二叉树
给你两棵二叉树： 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]
思路：还是一道构造二叉树的题，不过是变成了遍历两棵树
/**
* @param {TreeNode} root1
* @param {TreeNode} root2
* @return {TreeNode}
*/
var mergeTrees = function(root1, root2) {
if(root1&& root2 === null) return root1
// 这里包含了两棵树都为null return null 的情况
if(root1 === null ) return root2
const val = root1.val + root2.val
const root = new TreeNode(val)
root.left = mergeTrees(root1.left, root2.left)
root.right = mergeTrees(root1.right, root2.right)
return root
};
700. 二叉搜索树中的搜索
给定二叉搜索树（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
输出： []
二叉搜索树： 二叉搜索树是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
思路：基于二叉搜索树的特点（左<中<右），遍历树寻找一个节点
/**
* @param {TreeNode} root
* @param {number} val
* @return {TreeNode}
*/
var searchBST = function (root, val) {
if (root === null) return null
if (root.val === val) return root
return val > root.val ? searchBST(root.right, val): searchBST(root.left, val)
};
98. 验证二叉搜索树
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
- 节点的左子树只包含 小于 当前节点的数。
- 节点的右子树只包含 大于 当前节点的数。
- 所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
输入： root = [2,1,3]
输出： true
示例 2：
输入： root = [5,1,4,null,null,3,6]
输出： false
解释： 根节点的值是 5 ，但是右子节点的值是 4 。
思路： 左<中 <右，所以使用中序遍历，其中有一个要注意的点，每个节点，不仅要大于左节点小于右节点，还要大于之前出现过的最大值(右子树的任意节点一定大于左子树）才算符合条件，所以要在递归函数外存储一个变量max
/**
* @param {TreeNode} root
* @return {boolean}
*/
var isValidBST = function (root) {
let flag = true
let max = null
const isValid = (node) => {
if (!flag || !node) return
node.left && isValid(node.left)
if (node.left && node.val <= node.left.val) {
flag = false
return
}
if (max && node.val <= max) {
flag = false
return
}
if (node.right && node.val >= node.right.val) {
flag = false
return
} else {
max = max ? Math.max(node.val, max) : node.val
node.right && isValid(node.right)
}
}
isValid(root)
return flag
};
