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

 654.最大二叉树

class Solution {
    // 主函数，根据给定的数组构建最大二叉树
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        // 从数组的起始位置到结束位置构建最大二叉树
        return construct(nums, 0, nums.length);
    }

    // 辅助函数，用于在给定范围内构建最大二叉树
    public TreeNode construct(int[] nums, int l, int r) {
        // 如果起始位置等于结束位置，说明没有元素，返回 null
        if (l == r)
            return null;

        // 找到给定范围内的最大值的索引
        int max_i = max(nums, l, r);

        // 使用最大值创建新的树节点
        TreeNode root = new TreeNode(nums[max_i]);

        // 递归地在最大值左侧的子数组上构建左子树
        root.left = construct(nums, l, max_i);

        // 递归地在最大值右侧的子数组上构建右子树
        root.right = construct(nums, max_i + 1, r);

        // 返回构建的树的根节点
        return root;
    }

    // 辅助函数，用于在给定范围内找到数组的最大值的索引
    public int max(int[] nums, int l, int r) {
        int max_i = l;
        // 遍历数组的指定范围
        for (int i = l; i < r; i++) {
            // 如果找到更大的值，更新最大值的索引
            if (nums[max_i] < nums[i])
                max_i = i;
        }
        // 返回最大值的索引
        return max_i;
    }
}

617.合并二叉树 

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){
            return null;
        }
        if(root.val == val){
            return root;
        }
        if(root.val < val){
            return searchBST(root.right,val);
        }
        if(root.val > val){
            return searchBST(root.left,val);
        }

        return null;
    }
}

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 {
    public boolean isValidBST(TreeNode root) {
        return isValidBSTHelper(root,null,null);
    }

    private boolean isValidBSTHelper(TreeNode node, Integer min, Integer max){
        if(node == null){
            return true;
        }

        int val =node.val;

        // 检查节点的值是否在【min,max】范围内
        if(min != null && val <= min){
            return false;
        }

        if(max != null && val >= max){
            return false;
        }

        // 递归检查左子树和右子树
        // 对于左子树 上限是当前节点的值 即最大值更新为当前节点的值
        // 对于右子树 下限是当前节点的值 即最小值更新为当前节点的值
        return isValidBSTHelper(node.left,min,val) && isValidBSTHelper(node.right,val,max);
    }
}