二叉树 part06
day20-1 654.最大二叉树
构造二叉树的流程
选取最大的元素作为根节点
左区间选取最大的元素作为左子树的根节点
右区间选取最大的元素作为右子树的根节点
构造二叉树的题目都要用前序遍历:中左右,中用来构造根节点
代码实现
// 分割 构造
/**
* 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) {
return constructMaximumBinaryTreeImprove(nums, 0, nums.length);
}
private TreeNode constructMaximumBinaryTreeImprove(int[] nums, int leftIndex, int rightIndex){
// 没有元素
if(rightIndex -leftIndex < 1){
return null;
}
// 只有一个元素(说明到根节点了)
if(rightIndex - leftIndex == 1){
return new TreeNode(nums[leftIndex]);
}
// 中
int maxIndex = leftIndex; // 分割会用到
int maxVal = nums[maxIndex]; // 构造节点会用到
// 区间:左闭右开[)
for(int i = leftIndex + 1; i < rightIndex; i++){
if(nums[i] > maxVal){
maxVal = nums[i];
maxIndex = i;
}
}
// 构造根节点
TreeNode root = new TreeNode(maxVal);
// 左
root.left = constructMaximumBinaryTreeImprove(nums, leftIndex, maxIndex);
// 右
root.right = constructMaximumBinaryTreeImprove(nums, maxIndex + 1, rightIndex);
return root;
}
}
总结
区间统一:左闭右开
day20-2 617.合并二叉树
思路以及遍历顺序
递归法代码最少
中序遍历比较符合正常的思维逻辑
代码实现
/**
* 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 mergeTrees(TreeNode root1, 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;
}
}
改变顺序
只需简单移动对应的三段代码即可
定义新二叉树
用新二叉树替换掉使用tree1的不部分即可
总结
和判断是否是对称二叉树的题目比较类似,本质都是同时操作两棵二叉树
day20-3 700.二叉搜索树中的搜索
搜索树的特性
自带顺序
递归法代码+递归法代码
/**
* 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 searchBST(TreeNode root, int val) {
// if(root == null || root.val == val){
// return root;
// }
// TreeNode result = null;
// if(val < root.val){
// result = searchBST(root.left, val);
// }
// if(val > root.val){
// result = searchBST(root.right, val);
// }
// return result;
// }
// 迭代法
public TreeNode searchBST(TreeNode root, int val) {
while(root != null){
if(val < root.val){
root = root.left;
}else if(val > root.val){
root = root.right;
}else{
return root;
}
}
return null;
}
}
总结
二叉搜索树特性:自带顺序
day20-4 98.验证二叉搜索树
搜索树的特性
节点的左子树只包含小于当前节点的树
节点的右子树只包含大于当前节点的树
所有的左子树和右子树自身也是二叉搜索树
中序遍历单调递增
直白想法
把二叉树转变成数组然后判断数组是否有序
代码误区
- 单词的比较左节点小于中间节点,右节点大于中间节点×
- 比较的应该是左子树所有节点小于中间节点,右子树的所有节点大于中间节点√
代码实现
/**
* 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 {
// 递归法1
ArrayList<Integer> resList = new ArrayList<>();
public boolean isValidBST(TreeNode root) {
traversal(root);
for(int i = 1; i < resList.size(); i++){
if(resList.get(i - 1) >= resList.get(i)){
return false;
}
}
return true;
}
private void traversal(TreeNode root){
if(root == null){
return ;
}
traversal(root.left);
resList.add(root.val);
traversal(root.right);
}
// 递归法2
private long maxVal = Long.MIN_VALUE;
public boolean isValidBST(TreeNode root) {
if(root == null){
return true;
}
// 左
boolean left = isValidBST(root.left);
// 中
if(root.val >= maxVal){ // 右漏洞:第一个root.val可能等于Long.MIN_VALUE;
maxVal = root.val;
}else{
return false;
}
boolean right = isValidBST(root.right);
return left && right;
}
}
双指针优化
//递归法3 双指针 有点难理解 画图推演会更好
private TreeNode pre = null;
public boolean isValidBST(TreeNode root) {
if(root == null){
return true;
}
// 左
boolean left = isValidBST(root.left);
// 中
if(pre != null && pre.val >= root.val){
return false;
}
pre = root;
// 右
boolean right = isValidBST(root.right);
return left && right;
}
总结
判断是否是二叉搜索树要采用中序遍历,中序遍历的前提下,如果是二叉搜索树,遍历的元素就是一个有序数组。
双指针:pre 和 root