day18

654.代码随想录

和构造二叉树一样的思路，比较简单，注意在比较时每轮遍历nums的时候是从begin开始，end结束

class Solution {
    Map<Integer,Integer> map = new HashMap<>();
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        for(int i = 0;i < nums.length;i++){
            map.put(nums[i],i);
        }
        
        return getPreTree(nums,0,nums.length);
    }
    public TreeNode getPreTree(int[] nums,int begin, int end){
        if(begin >= end){
            return null;
        }
        int max = -1;
        for(int i = begin;i<end;i++){
            max = Math.max(max,nums[i]);
        }
        int index = map.get(max);
        int sub = index - begin;
        TreeNode root = new TreeNode(max);
        root.left = getPreTree(nums,begin,index);
        root.right = getPreTree(nums,index + 1,end);
        return root;
    }
}

617 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

考虑4种情况：

root1 == null && root2 == null:此时返回null；

root1 == null && root2 != null:此时返回root2;

root1 != null && root2 == null:此时返回root1;

root1 != null && root2 != null:此时返回的root的值为root1.val + root2.val

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        return merge(root1,root2);
    }
    public TreeNode merge(TreeNode root1, TreeNode root2){
        if(root1 == null){
            return root2;
        }
        if(root2 == null){
            return root1;
        }
        TreeNode root = new TreeNode(root1.val + root2.val);
        root.left = merge(root1.left,root2.left);
        root.right = merge(root1.right,root2.right);
        return root;
    }
}

 700.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

本题套路：

1.等于时，返回

2.大于时，去左子树查去

3.小于时，去右子树查去

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        return search(root,val);
    }
    public TreeNode search(TreeNode root,int val){
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }
        if(root.val > val){
            return search(root.left,val);
        }
        else{
            return search(root.right,val);
        }
        
    }
}

98.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

树的中序遍历升序则满足条件：
 

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public boolean isValidBST(TreeNode root) {
        valid(root);
        boolean res = true;
        for(int i = 1;i<list.size();i++){
            if(list.get(i) <= list.get(i - 1)){
                res = false;
            }
        }
        return res;
        
    }
    public void valid(TreeNode root){
        if(root == null){
            return ;
        }
        valid(root.left);
        list.add(root.val);
        valid(root.right);
    }
}

class Solution {
    TreeNode max;
    public boolean isValidBST(TreeNode root) {
        return valid(root);
        
    }
    public boolean valid(TreeNode root){
        if(root == null){
            return true;
        }
        boolean left = valid(root.left);
        //如果在left分支上已不满足要求，直接返回false即可
        if(!left){
            return false;
        }
        //这里的max记录的就是之前的值
        if(max != null && max.val >= root.val){
            return false;
        }
        max = root;
        boolean right = valid(root.right);
        return left && right;
    }
}