Day17 | 二叉树part05

617. 合并二叉树 - 力扣（LeetCode）

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

    }
}

654. 最大二叉树 - 力扣（LeetCode）

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        if(nums.length == 0) return null;
        return buileTree(nums,0,nums.length-1);
    }
    private TreeNode buileTree(int[] nums,int start,int end){
        if(start > end) return null;
        int rootVal = 0;
        if(start == end){
            rootVal = nums[start];
            return new TreeNode(rootVal);
        }
        int maxIndex = findMaxIndex(nums,start,end);
        TreeNode root = new TreeNode(nums[maxIndex]);
        
        root.left = buileTree(nums,start,maxIndex-1);
        root.right = buileTree(nums,maxIndex+1,end);
        return root;
    }
    private int findMaxIndex(int[] nums,int start,int end){
        int maxIndex = start;
        for(int i=start + 1;i<=end;i++){
            if(nums[i]>nums[maxIndex]){
                maxIndex = i;
            }
        }
        return maxIndex;
    }
}

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val)
            return root;
        return root.val < val ? searchBST(root.right, val) : searchBST(root.left, val);
    }
}

98. 验证二叉搜索树 - 力扣（LeetCode）

前序遍历

class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    private boolean isValidBST(TreeNode node,long min,long max){
        if(node == null){
            return true;
        }
        if(node.val <= min || node.val >= max){
            return false;
        }
        return isValidBST(node.left,min,node.val) && isValidBST(node.right,node.val,max);
    }
}

中序遍历

class Solution {
    private long pre = Long.MIN_VALUE;

    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        if (!isValidBST(root.left) || root.val <= pre) {
            return false;
        }
        pre = root.val;
        return isValidBST(root.right);
    }
}

后序遍历

class Solution {
    // 主方法，用来判断给定的树是否是有效的二叉搜索树
    public boolean isValidBST(TreeNode root) {
        long[] result = dfs(root);
        // 如果最大值不是 Long.MAX_VALUE，说明树中有重复的值或不符合二叉搜索树的定义
        return result[1] != Long.MAX_VALUE;
    }

    // 深度优先搜索方法，返回节点值范围
    private long[] dfs(TreeNode node) {
        // 如果节点为空，则返回最大可能的范围
        if (node == null) {
            return new long[]{Long.MAX_VALUE, Long.MIN_VALUE};
        }
        
        // 递归处理左子树
        long[] leftRange = dfs(node.left);
        // 递归处理右子树
        long[] rightRange = dfs(node.right);        
        long currentValue = node.val;
        
        // 检查当前节点是否违反了二叉搜索树的规则
        if (currentValue <= leftRange[1] || currentValue >= rightRange[0]) {
            // 如果违反了规则，返回无效范围
            return new long[]{Long.MIN_VALUE, Long.MAX_VALUE};
        }
        
        // 返回当前节点的有效范围
        return new long[]{Math.min(leftRange[0], currentValue), Math.max(rightRange[1], currentValue)};
    }
}