代码随想录刷题训练营DAY20|二叉树part6

654.最大二叉树

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：

• [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
  • [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
    • 空数组，无子节点。
    • [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
      • 空数组，无子节点。
      • 只有一个元素，所以子节点是一个值为 1 的节点。
  • [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
    • 只有一个元素，所以子节点是一个值为 0 的节点。
    • 空数组，无子节点。

思路：递归

• 确定递归参数和返回值
• 终止条件：传入的大小为1,比如[1]的时候，就遍历到了叶子结点。
• 单层递归逻辑
  1.找到最大值对应的下标，最大的值构造根节点。
  2.切割数组
  3.左区间构造左子树，右区间构造右子树。

/**
 * 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) {
        if(nums.length==0){
            return null;
        }
        return buildNode(nums, 0, nums.length-1);
    }

    /**
     * 构建结点
     * @param nums 数组
     * @param leftIndex 数组最左起位置（start）
     * @param rightIndex 数组最右位置（end）
     * @return
     */
    public TreeNode buildNode(int[] nums,int leftIndex,int rightIndex){
        if(leftIndex>rightIndex){
            return null;
        }
        //单层递归逻辑
        int rootIndex=findMax(nums,leftIndex,rightIndex);//最大值作为根节点
        TreeNode root=new TreeNode(nums[rootIndex]);//新建根节点
        root.left=buildNode(nums, leftIndex, rootIndex-1);//左节点
        root.right=buildNode(nums, rootIndex+1, rightIndex);//右节点
        return root;
    }

    /**
     * 寻找数组中最大值的下标
     * @param nums 数组
     * @param leftIndex 数组最左起位置（start）
     * @param rightIndex 数组最右位置（end）
     * @return
     */
    private int findMax(int[] nums, int leftIndex, int rightIndex) {
        int maxIndex = leftIndex; // 从左索引开始假设最大值
        for (int i = leftIndex + 1; i <= rightIndex; i++) {
            if (nums[i] > nums[maxIndex]) {
                maxIndex = i; // 更新最大值的下标
            }
        }
        return maxIndex; // 返回最大值的下标
    }
}

617.合并二叉树

思路：层次遍历

• 每一次将t1和t2入队
• 如果任意一个结点为空，无需合并；否则合并当前的结点
• 如果node1的左子树为空，就用node2的左子树，否则将两个左子树加入队列继续合并
• 处理右子树的逻辑也一样

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null) return t2;
        if (t2 == null) return t1;

        // 使用队列进行层次遍历
        Queue<TreeNode[]> queue = new LinkedList<>();
        queue.add(new TreeNode[]{t1, t2});

        while (!queue.isEmpty()) {
            TreeNode[] current = queue.poll();//当前同一层，两棵树的结点
            TreeNode node1 = current[0], node2 = current[1];

            // 如果任一节点为空，不需要合并
            if (node1 == null || node2 == null) {
                continue;
            }

            // 合并当前节点
            node1.val += node2.val;

            // 如果node1的左子树为空，我们就用node2的左子树
            if (node1.left == null) {
                node1.left = node2.left;
            } else {
                // 否则，将两个左子树加入队列继续合并
                queue.add(new TreeNode[]{node1.left, node2.left});
            }

            // 同理处理右子树
            if (node1.right == null) {
                node1.right = node2.right;
            } else {
                queue.add(new TreeNode[]{node1.right, node2.right});
            }
        }

        return t1;
    }
}

700.二叉搜索树中的搜索

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if(root==null){
            return null;
        }
        if(root.val==val){
            return root;
        }
        //递归
        if(root.val>val){//当前结点的值大于val值，往左边搜索，否则往右边搜索
            return searchBST(root.left, val);
        }else{
            return searchBST(root.right, val);
        }
    }
}

98.验证二叉搜索树

注意点：左子树单单小于根节点，左子树还要小于所有右子树。所以根据根节点的值来设定最大最小值。保证左子树最大不超过根节点，右子树最小不超过根节点，就能包含多种情况。

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

    public boolean validate(TreeNode root,long low,long max){
        if(root==null){
            return true;
        }
        //左子树的最大值是根节点
        //右子树的最小值是根节点
        if(root.val<=low||root.val>=max){
            return false;
        }
        
        boolean left=validate(root.left,low,root.val);
        boolean right=validate(root.right, root.val, max);
        return left&&right;
    }
}