代码随想录训练营第二十天 | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

654.最大二叉树

该题就是先在数组中查找最大值 maxVal，然后构建为根节点，然后对 maxVal 左边的数组和右边的数组进行递归构建，作为 root 的左右子树。

代码如下：

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return build(nums,0,nums.length - 1);
    }
    
    public TreeNode build(int[] nums,int lo, int hi){
        if(lo > hi){
            return null;
        }

        int index = -1;
        int maxVal = Integer.MIN_VALUE;
        // 查找数组中的最大值和对应索引值
        for(int i = lo;i <= hi;i++){
            if(maxVal < nums[i]){
                index = i;
                maxVal = nums[i];
            }
        }

        // 递归构建左右子树
        TreeNode root = new TreeNode(maxVal);
        root.left = build(nums, lo, index - 1);
        root.right = build(nums, index + 1, hi);
        return root;
    }
}

617.合并二叉树

关键是遍历的过程中，你要对每个节点做什么，其实也很简单，按照题目的要求将两棵二叉树的每个节点合并即可。

代码如下：

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;
    }
}

700.二叉搜索树中的搜索

首先二叉搜索树特性：

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

所以根据二叉搜索树左小右大特性进行递归搜索

代码如下：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if(root == null){
            return null;
        }
        
        // 利用"左小右大"
        if(root.val > val){ // 如果当前节点值大于目标值，则说明目标值在左子树
            return searchBST(root.left,val);
        }else if(root.val < val){
            return searchBST(root.right,val);
        }else{
            return root;
        }
    }
}

98.验证二叉搜索树

首先在卡哥的提示下，利用二叉搜索树中序遍历特性写出了代码

class Solution {
    List<Integer> val = new ArrayList<>();
    public boolean isValidBST(TreeNode root) {
        traverse(root,val);
        for(int i = 0;i < val.size() - 1;i++){
            if(val.get(i) >= val.get(i + 1)){
                return false;
            }
        }
        return true;
    }


    public List<Integer> traverse(TreeNode root,List<Integer> val){
        if(root == null){
            return val;
        }
        
        traverse(root.left,val);
        val.add(root.val);
        traverse(root.right,val);
        return val;
    }
}

 再进行优化：

在中序遍历的过程中就判断前一个节点是否满足升序

代码如下：

class Solution {
    // 测试用例由于存在int最小值测试，所以使用long类型
    long pre = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }

        // 访问左子树
        if(isValidBST(root.left) == false){
            return false;
        }

        // 访问当前节点，如果当前节点小于等于中序遍历的前一个节点，则说明不满足BST定义
        if(root.val <= pre){
            return false;
        }
        pre = root.val;

        // 访问右子树
        return isValidBST(root.right);
    }
}

 

【递归】思维解题，有一个坑

BST 不是左小右大么，那我只要检查 root.val > root.left.val 且 root.val < root.right.val 不就行了？

注：这样是不对的，因为 BST 左小右大的特性是指 root.val 要比左子树的所有节点都更大，要比右子树的所有节点都小，你只检查左右两个子节点当然是不够的。

如图：

 所以创建一个辅助函数来增加限制参数，来进行判断

使用【上界，下界】来判断当前节点值是否满足在这个值区间内

代码如下：

class Solution {
    public boolean isValidBST(TreeNode root) {
        // 根节点时的上下界为（正负无穷）
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public boolean isValidBST(TreeNode root, long minVal, long maxVal){
        if(root == null){
            return true;
        }

        // 判断是否满足BST定义
        if(root.val <= minVal) return false;
        if(root.val >= maxVal) return false;

        // 利用递归过程不断缩小【上界，下界】范围
        return isValidBST(root.left,minVal,root.val)
            && isValidBST(root.right,root.val,maxVal);
    }
}