第21天| 654.最大二叉树 , 617.合并二叉树 ,700.二叉搜索树中的搜索

654.最大二叉树
https://leetcode.cn/problems/maximum-binary-tree/

/**
 * 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 build(nums, 0, nums.length - 1);
    }

    public TreeNode build(int[] nums, int startIndex, int endIndex) {
        if (startIndex > endIndex) return null;
        int index = maxElementIndex(nums, startIndex, endIndex);
        TreeNode newNode = new TreeNode(nums[index]);
        newNode.left = build(nums, startIndex, index - 1);
        newNode.right = build(nums, index + 1, endIndex);
        return newNode;
    }

    public int maxElementIndex(int[] nums, int startIndex, int endIndex) {
        int maxIndex = startIndex;
        for (int i = startIndex + 1; i <= endIndex; i++) {
            maxIndex = nums[maxIndex] < nums[i] ? i : maxIndex;
        }
        return maxIndex;
    }
}

/*
1. 构建一个公共方法constructMaximumBinaryTree(nums)，该方法调用私有方法build(nums, startIndex, endIndex)，其中 startIndex 为数组的起始索引，endIndex为数组的结束索引。
2. 在私有方法build(nums, startIndex, endIndex) 中，首先判断如果startIndex > endIndex，则返回 null 。
3. 然后调用私有方法maxElementIndex(nums, startIndex, endIndex)，找到数组nums在范围 [startIndex, endIndex]内的最大元素的索引，记为index。
4. 创建一个新的节点newNode ，值为 nums[index] 。
5. 递归构建 newNode 的左子树，调用 build(nums, startIndex, index - 1) 。
6. 递归构建 newNode 的右子树，调用 build(nums, index + 1, endIndex) 。
7. 返回 newNode 作为当前子树的根节点。

私有方法 maxElementIndex(nums, startIndex, endIndex) 用于找到数组 nums 在给定范围内的最大元素的索引，具体步骤为：
1. 初始化 maxIndex = startIndex ，即将最大元素的索引初始化为范围内的第一个元素索引。
2. 遍历范围内的元素，如果发现更大的元素，则更新 maxIndex 为该元素的索引。
3. 返回 maxIndex 作为最大元素的索引。

这样递归构建最大二叉树的过程会不断地将数组划分成左右两个子数组，直到子数组为空时返回 null ，从而构建出整个最大二叉树。*/

617.合并二叉树 

. - 力扣（LeetCode）

/**
 * 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 || root2==null) {
            return root1 == null ? root2 : root1;
        }
        return dfs(root1, root2);
    }

    TreeNode dfs(TreeNode r1, TreeNode r2) {

        if (r1 == null || r2 == null) {
            return r1 == null ? r2 : r1;
        }
        // 让r1的值 等于 r1和r2的值累加，再递归的计算两颗树的左节点、右节点
        r1.val += r2.val;

        r1.left = dfs(r1.left, r2.left);
        r1.right = dfs(r1.right, r2.right);
        return r1;

    }

}

700.二叉搜索树中的搜索

. - 力扣（LeetCode）

/**
 * 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 (val < root.val) {
            return searchBST(root.left, val);
        } else {
            return searchBST(root.right, val);
        }
    }
}