训练营day20|二叉树（最大二叉树|合并二叉树|二叉搜索树中的搜索|验证二叉搜索树）

目录

654.最大二叉树

617.合并二叉树

700.二叉搜索树中的搜索

98.验证二叉搜索树

---

654.最大二叉树

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

 注意区间范围，递归是[leftindex,rightindex]  故遍历的时候要包含左右边界，并且maxindex本身是不参与递归过程。

class Solution {
    /**
     * 构造最大二叉树,类似于大顶堆
     *
     * @param nums
     * @return
     */
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return dou(nums, 0, nums.length - 1);
    }

    public TreeNode dou(int[] nums, int leftindex, int rightindex) {
        if (leftindex > rightindex) {
            return null;
        }
        if (leftindex == rightindex) {
            return new TreeNode(nums[leftindex]);
        }
        int maxnum = Integer.MIN_VALUE, maxindex = leftindex;
        for (int i = leftindex; i <= rightindex; i++) {
            if (nums[i] > maxnum) {
                maxnum = nums[i];
                maxindex = i;
            }
        }
        TreeNode root = new TreeNode(maxnum);
        root.left = dou(nums, leftindex, maxindex - 1);
        root.right = dou(nums, maxindex + 1, rightindex);
        return root;
    }
}

---

617.合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

class Solution {
    /**
     * 合并两个二叉树，相同的结点和值
     *
     * @param root1
     * @param root2
     * @return
     */
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        return dou(root1, root2);
    }

    public TreeNode dou(TreeNode root1, TreeNode root2) {
        //递归的出口
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        //单层递归的逻辑
        TreeNode ans = new TreeNode(root1.val + root2.val);
        ans.left = dou(root1.left, root2.left);
        ans.right = dou(root1.right, root2.right);
        return ans;
    }
}

---

700.二叉搜索树中的搜索

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

 迭代方法，将二叉树每个结点层序遍历。

class Solution {
    /**
     * 在二叉搜索树中搜索--->迭代
     *
     * @param root
     * @param val
     * @return
     */
    public TreeNode searchBST(TreeNode root, int val) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return null;
        }
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            if (temp.val == val) {
                return temp;
            }
            if (temp.left != null) {
                queue.add(temp.left);
            }
            if (temp.right != null) {
                queue.add(temp.right);
            }
        }
        return null;//不存在
    }
}

 二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

 递归方法，基于二叉搜索树的特性，左子树的值<根结点的值，右子树的值>根节点的值

确定递归的方向。当然迭代也可以利用这个方向进行优化。

 

class Solution {
    /**
     * 在二叉搜索树中搜索
     *
     * @param root
     * @param val
     * @return
     */
    public TreeNode searchBST(TreeNode root, int val) {
        return search(root, val);
    }

    public TreeNode search(TreeNode root, int val) {
        //递归出口
        if (root == null || root.val == val) {
            return root;
        }
        //单层递归逻辑
        TreeNode ans = new TreeNode();
        if (root.val > val) {
            ans = search(root.left, val);
        }
        if (root.val < val) {
            ans = search(root.right, val);
        }
        return ans;
    }
}

 

---

98.验证二叉搜索树

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。

 而且二叉搜索树在中序遍历后的数组中呈单调递增，利用这个特性来写递归函数

利用long的min值的主要原因是LeetCode的测试案例有int类型的min值故采用long的min值。

class Solution {
    /**
     * 判断是否是二叉搜索树
     * 左侧的数的值都小于根结点，右侧的数值大于根节点
     *
     * @param root
     * @return
     */
    public boolean isValidBST(TreeNode root) {
        return isValid(root);
    }

    long max = Long.MIN_VALUE;

    public boolean isValid(TreeNode root) {
        //递归的出口
        if (root == null) {
            return true;
        }
        boolean leftflag = isValid(root.left);//保留其返回值
        if (max < root.val) {
            max = root.val;//当一个中间媒介，保留中序遍历的前一个值
        } else {
            return false;
        }
        boolean rightflag = isValid(root.right);
        return leftflag && rightflag;
    }
}