第六章二叉树part06 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/qq_45498567/article/details/132538537

第二十天| 第六章二叉树part06 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

一、654.最大二叉树

题目链接：https://leetcode.cn/problems/maximum-binary-tree/
题目介绍：
- 给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
  1. 创建一个根节点，其值为 nums 中的最大值。
  2. 递归地在最大值左边的 子数组前缀上 构建左子树。
  3. 递归地在最大值右边的 子数组后缀上 构建右子树。
  返回 nums 构建的 *最大二叉树* 。
思路：
- 本题要求构造二叉树，和昨天的前中、后中构造二叉树思路一致
- 主要有两个关键点：
  - 确定边界开闭原则
  - 确定边界index
代码：
- 本题我使用一个优先级队列解决，思路和求解数组高频k元素类似
  - 大顶堆，优先级队列的第一个元素就是最大值
  - 边界条件：
    - 左：[beginIndex, rootIndex)
    - 右：[rootIndex + 1, endIndex)

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        int beginIndex = 0;
        int endIndex = nums.length;
        return traversal(nums, beginIndex, endIndex);
    }

    public TreeNode traversal(int[] nums, int beginIndex, int endIndex) {
        if (beginIndex >= endIndex) return null;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = beginIndex; i < endIndex; i++) {
            map.put(nums[i], i);
        }
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[0] - pair1[0]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            pq.offer(new int[]{entry.getKey(), entry.getValue()});
        }
        int rootIndex = pq.peek()[1];
        TreeNode root = new TreeNode(pq.peek()[0]);
        root.left = traversal(nums, beginIndex, rootIndex);
        root.right = traversal(nums, rootIndex + 1, endIndex);
        return root;
    }
}

二、617.合并二叉树

题目链接：https://leetcode.cn/problems/merge-two-binary-trees/
题目介绍：
- 想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
- 返回合并后的二叉树。
- 注意: 合并过程必须从两个树的根节点开始。
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rAWI5xSB-1693204566339)(合并二叉树.png)]

思路：

中前后均可，但是中是最好理解的

递归三部曲：

（1）确定返回值和参数

TreeNode traversal(TreeNode t1, TreeNode t2) {}

（2）终止条件

if (t1 == null) return t2;
if (t2 == null) return t1;

（3）单层递归的逻辑

// 重复利用树t1
t1.val += t2.val;
t1.left = traversal(t1.left, t2.left);
t1.right = traversal(t1.right, t2.right);
return t1;

代码：

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.二叉搜索树中的搜索

二叉搜索树（BST）是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
二叉搜索树的特性决定了其==中序遍历一定是有序的==。
二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。
题目链接：https://leetcode.cn/problems/search-in-a-binary-search-tree/
题目介绍：
- 给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
- 你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。
思路：
- 根据二叉搜索树的特性解决该问题，如果目标值小于root.val，就在root的左子树上查找；如果目标值大于root.val，就在root的右子树上查找。
- 递归和迭代都是这个思路。
代码：

（1）递归：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        // 根据二叉搜索树的特性解决该问题
        // 如果根节点为空或者根节点的值和目标值相等，就返回根
        if (root == null || val == root.val) return root;
        TreeNode result = null;
        if (val < root.val) result = searchBST(root.left, val);
        if (val > root.val) result = searchBST(root.right, val);
        return result;
    }
}

（2）迭代：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while (root != null)
            if (val < root.val) root = root.left;
            else if (val > root.val) root = root.right;
            else return root;
        return null;
    }
}

四、98.验证二叉搜索树

题目链接：https://leetcode.cn/problems/validate-binary-search-tree/
题目介绍：
- 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
  
  有效二叉搜索树定义如下：
  - 节点的左子树只包含小于当前节点的数。
  - 节点的右子树只包含大于当前节点的数。
  - 所有左子树和右子树自身必须也是二叉搜索树。
思路：
- 本题需要用到二叉搜索树的特性，中序遍历是有序的
  - 思路1：定义一个数组，把二叉树遍历一遍放入数组中，判断这个数组是否是单调递增的
  - 思路2：在递归的过程中进行判断，这里谨防一个误区：如果判断当前根节点的值大于左孩子的值 && 当前根节点的值小于右孩子的值就return true；这样是不正确的。**二叉搜索树的定义，强调的是，根节点的值小于左子树的所有值，大于右子树的所有值，而不仅是当前节点的左右孩子。 **
    - 如何判断中序遍历节点的值满足单调递增呢？
      - 首先采用中序遍历；
      - 其次如何处理中节点呢？定义一个pre指针，表示的是前一个中节点，如果前一个中节点的值大于等于当前root.val，说明不是二叉搜索树，return false。
代码：

递归 + 双指针：

class Solution {
    // 定义一个pre指针 = null
    // 一定要定义为一个全局变量，因为在递归的过程中要不断更新，不能重新赋值为null
    // 可以这么想：从左子树的第一个左叶子节点，它的前一个节点就是null
    TreeNode pre = null;
    public boolean isValidBST(TreeNode root) {
        // 1. 递归结束的条件，根节点为null，返回true (因为null，也是一个二叉搜索树)
        if (root == null) return true;
        // 2. 确定单层递归的逻辑 (采用中序遍历)
        // 左：
        boolean left = isValidBST(root.left);
        // 中：
        if (pre != null && pre.val >= root.val) return false;
        // 将本轮递归的根节点赋给pre，下一轮递归的时候比较的就是前一轮的root和本轮root
        pre = root;
        // 右：
        boolean right = isValidBST(root.right);
        return left && right;
    }
}