654.最大二叉树
示例 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] 。
思路:递归
- 确定递归参数和返回值
- 终止条件:传入的大小为1,比如[1]的时候,就遍历到了叶子结点。
- 单层递归逻辑
1.找到最大值对应的下标,最大的值构造根节点。
2.切割数组
3.左区间构造左子树,右区间构造右子树。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode constructMaximumBinaryTree(int[] nums) {
if(nums.length==0){
return null;
}
return buildNode(nums, 0, nums.length-1);
}
/**
* 构建结点
* @param nums 数组
* @param leftIndex 数组最左起位置(start)
* @param rightIndex 数组最右位置(end)
* @return
*/
public TreeNode buildNode(int[] nums,int leftIndex,int rightIndex){
if(leftIndex>rightIndex){
return null;
}
//单层递归逻辑
int rootIndex=findMax(nums,leftIndex,rightIndex);//最大值作为根节点
TreeNode root=new TreeNode(nums[rootIndex]);//新建根节点
root.left=buildNode(nums, leftIndex, rootIndex-1);//左节点
root.right=buildNode(nums, rootIndex+1, rightIndex);//右节点
return root;
}
/**
* 寻找数组中最大值的下标
* @param nums 数组
* @param leftIndex 数组最左起位置(start)
* @param rightIndex 数组最右位置(end)
* @return
*/
private int findMax(int[] nums, int leftIndex, int rightIndex) {
int maxIndex = leftIndex; // 从左索引开始假设最大值
for (int i = leftIndex + 1; i <= rightIndex; i++) {
if (nums[i] > nums[maxIndex]) {
maxIndex = i; // 更新最大值的下标
}
}
return maxIndex; // 返回最大值的下标
}
}
617.合并二叉树
思路:层次遍历
- 每一次将t1和t2入队
- 如果任意一个结点为空,无需合并;否则合并当前的结点
- 如果node1的左子树为空,就用node2的左子树,否则将两个左子树加入队列继续合并
- 处理右子树的逻辑也一样
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class Solution {
public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
if (t1 == null) return t2;
if (t2 == null) return t1;
// 使用队列进行层次遍历
Queue<TreeNode[]> queue = new LinkedList<>();
queue.add(new TreeNode[]{t1, t2});
while (!queue.isEmpty()) {
TreeNode[] current = queue.poll();//当前同一层,两棵树的结点
TreeNode node1 = current[0], node2 = current[1];
// 如果任一节点为空,不需要合并
if (node1 == null || node2 == null) {
continue;
}
// 合并当前节点
node1.val += node2.val;
// 如果node1的左子树为空,我们就用node2的左子树
if (node1.left == null) {
node1.left = node2.left;
} else {
// 否则,将两个左子树加入队列继续合并
queue.add(new TreeNode[]{node1.left, node2.left});
}
// 同理处理右子树
if (node1.right == null) {
node1.right = node2.right;
} else {
queue.add(new TreeNode[]{node1.right, node2.right});
}
}
return t1;
}
}
700.二叉搜索树中的搜索
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if(root==null){
return null;
}
if(root.val==val){
return root;
}
//递归
if(root.val>val){//当前结点的值大于val值,往左边搜索,否则往右边搜索
return searchBST(root.left, val);
}else{
return searchBST(root.right, val);
}
}
}
98.验证二叉搜索树
注意点:左子树单单小于根节点,左子树还要小于所有右子树。所以根据根节点的值来设定最大最小值。保证左子树最大不超过根节点,右子树最小不超过根节点,就能包含多种情况。
class Solution {
public boolean isValidBST(TreeNode root) {
return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
public boolean validate(TreeNode root,long low,long max){
if(root==null){
return true;
}
//左子树的最大值是根节点
//右子树的最小值是根节点
if(root.val<=low||root.val>=max){
return false;
}
boolean left=validate(root.left,low,root.val);
boolean right=validate(root.right, root.val, max);
return left&&right;
}
}