算法练习第十九天|654.最大二叉树、 617.合并二叉树、 700.二叉搜索树中的搜索、98.验证二叉搜索树

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 createTreeNode(nums,0,nums.length);
    }

    public TreeNode createTreeNode(int[] nums,int leftIndex,int rightIndex){
        
        if(rightIndex == leftIndex +1) return new TreeNode(nums[leftIndex]);
        if(rightIndex < leftIndex +1) return null;
        int maxValue = nums[leftIndex];
        int maxValueIndex = leftIndex;

        for(int i = leftIndex + 1;i<rightIndex;i++){
            if(nums[i]>maxValue){
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        TreeNode root = new TreeNode(maxValue);
        root.left = createTreeNode(nums,leftIndex,maxValueIndex);
        root.right = createTreeNode(nums,maxValueIndex+1,rightIndex);
        return root;
    }
}

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

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;

    //     if(root.val > val){
    //         return searchBST(root.left,val);
    //     }else{
    //         return searchBST(root.right,val);
    //     }
    // }


    public TreeNode searchBST(TreeNode root, int val) {
        if(root == null) return root;

        while(root != null){
            if(root.val > val) root = root.left;
            else if(root.val < val) root = root.right;
            else return root;
        }
        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 {
    // List<Integer> list = new ArrayList<>();
    // public boolean isValidBST(TreeNode root) {
    //     createNums(root);
    //     for(int i = 1;i<list.size();i++){
    //         if(list.get(i-1)>=list.get(i)){
    //             return false;
    //         }
    //     }
    //     return true;

    // }

    // public void createNums(TreeNode root){
    //     if(root == null) return ;
    //     isValidBST(root.left);
    //     list.add(root.val);
    //     isValidBST(root.right);
    // }

    TreeNode max;
    public boolean isValidBST(TreeNode root) {
        if(root==null) return true;
        if(!isValidBST(root.left)) return false;

        if(max!=null && root.val <= max.val) return false;
        max = root;
        return isValidBST(root.right);
    }
}