代码随想录算法训练营第17天| 654.最大二叉树， 617.合并二叉树， 700.二叉搜索树中的搜索，98.验证二叉搜索树

学习任务：

• Leetcode654.最大二叉树
• Leetcode617.合并二叉树
• Leetcode700.二叉搜索树中的搜索
• Leetcode98.验证二叉搜索树

---

Leetcode654.最大二叉树

难度：中等 | 相关标签：栈、树、数组、分治、二叉树、单调栈

• 题目： 给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
  • 创建一个根节点，其值为 nums 中的最大值。
  • 递归地在最大值 左边 的 子数组前缀上 构建左子树。
  • 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

• 思路：

• 注意：

  • 构造二叉树类的题目要用前序遍历
  • 类似用数组构造二叉树的题目，每次分隔尽量不要定义新的数组，而是通过下标索引直接在原数组上操作，这样可以节约时间和空间上的开销

• 代码：

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return constructTree(nums, 0, nums.length);
    }

    public TreeNode constructTree(int[] nums, int leftIndex, int rightIndex) {
        if (rightIndex - leftIndex < 1) {// 没有元素
            return null;
        }
        if (rightIndex - leftIndex == 1) {// 只有一个元素
            return new TreeNode(nums[leftIndex]);
        }
        int maxIndex = leftIndex;// 最大值所在位置
        int maxVal = nums[maxIndex];// 最大值
        for (int i = leftIndex + 1; i < rightIndex; i++) {
            if (nums[i] > maxVal){
                maxVal = nums[i];
                maxIndex = i;
            }
        }
        TreeNode root = new TreeNode(maxVal);
        // 根据maxIndex划分左右子树
        root.left = constructTree(nums, leftIndex, maxIndex);
        root.right = constructTree(nums, maxIndex + 1, rightIndex);
        return root;
    }
}

• 反思：

---

Leetcode617.合并二叉树

难度：简单 | 相关标签：树、深度优先搜索、广度优先搜索、二叉树

• 题目： 给你两棵二叉树： root1 和 root2 。
  想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
  返回合并后的二叉树。
  注意: 合并过程必须从两个树的根节点开始。

• 思路： 其实和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作。采用前中后序遍历都可以

• 注意：

  • 确定终止条件：
    • 因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 == NULL 了，两个树合并就应该是 t2 了（如果t2也为NULL也无所谓，合并之后就是NULL）。
    • 反过来如果t2 == NULL，那么两个数合并就是t1（如果t1也为NULL也无所谓，合并之后就是NULL）

• 代码：

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null){
            return root2;
        }
        if(root2 == null){
            return root1;
        }
        // 中
        root1.val = root1.val +root2.val;
        //左
        root1.left = mergeTrees(root1.left, root2.left);
        // 右
        root1.right = mergeTrees(root1.right, root2.right);
        return root1;
    }
}

• 反思：

---

Leetcode700.二叉搜索树中的搜索

难度：简单 | 相关标签：树、二叉搜索树、二叉树

• 题目： 给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
  你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

• 思路：

  1. 确定递归函数的参数和返回值
     递归函数的参数传入的就是根节点和要搜索的数值，返回的就是以这个搜索数值所在的节点。
  2. 确定终止条件
     如果root为空，或者找到这个数值了，就返回root节点。
  3. 确定单层递归的逻辑
     因为二叉搜索树的节点是有序的，所以可以有方向的去搜索。
     如果root->val > val，搜索左子树，如果root->val < val，就搜索右子树，最后如果都没有搜索到，就返回NULL。

• 注意：

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

• 代码：

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);
        }
        if(root.val < val){
            return searchBST(root.right, val);
        }
        return null;
    }
}

• 反思：

---

Leetcode98.验证二叉搜索树

难度：中等 | 相关标签：树、深度优先搜索、二叉搜索树、二叉树

• 题目： 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
  有效 二叉搜索树定义如下：

  • 节点的左子树只包含 小于 当前节点的数。
  • 节点的右子树只包含 大于 当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

• 思路： 中序遍历下，输出的二叉搜索树节点的数值是有序序列。有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了
  可以递归中序遍历将二叉搜索树转变成一个数组。然后只要比较一下，这个数组是否是有序的

• 注意：

  • 二叉搜索树中不能有重复元素

• 代码：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    private List<Integer> list = new ArrayList<>();

    public boolean isValidBST(TreeNode root) {
        list.clear();
        traversal(root);
        for (int i = 1; i < list.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (list.get(i) <= list.get(i - 1)) return false;
        }
        return true;
    }

    private void traversal(TreeNode root) {
        if (root == null) return;
        traversal(root.left);
        list.add(root.val); // 将二叉搜索树转换为有序数组
        traversal(root.right);
    }
}

• 反思：