代码随想录算法训练营Day20|Leetcode654最大二叉树、Leetcode617合并二叉树、Leetcode700二叉搜索树中的搜索、Leetcode98验证二叉搜索树

Day20打卡！ 时长：1.5h

今日感想：涉及构造二叉树、操作两个二叉树和二叉搜索树。

Leetcode654 最大二叉树

题目链接：Leetcode654 最大二叉树

第一想法：拿到这题有点懵，仔细看了题和解释才明白，是一个不断递归的活。

讲解后想法：构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

递归三部曲

1.确定递归函数的参数和返回值

参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点。

2.确定终止条件

题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。那么应该定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。 这表示一个数组大小是1的时候，构造了一个新的节点，并返回。

3.确定单层递归的逻辑

（1）先要找到数组中最大的值和对应的下标， 最大的值构造根节点，下标用来下一步分割数组。

（2）最大值所在的下标左区间，构造左子树.这里要判断maxValueIndex > 0，因为要保证左区间至少有一个数值。

（3）最大值所在的下标右区间 构造右子树

判断maxValueIndex < (nums.size() - 1)，确保右区间至少有一个数值。

难点/细节：①类似用数组构造二叉树的题目，尽量不要定义新的数组，而是通过下标索引直接在原数组上操作。

②如果让空节点（空指针）进入递归，就不加if；如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。

代码：

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

    public TreeNode constructMaximumBinaryTree1(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 = constructMaximumBinaryTree1(nums, leftIndex, maxIndex);
        root.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);
        return root;
    }
}

Leetcode617 合并二叉树

题目链接：Leetcode617 合并二叉树

第一想法：同时遍历两棵树，但是怎么操作呢？

讲解后想法：前中后序都可以，前序好理解。

递归三部曲

1.确定递归函数的参数和返回值

首先要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并后二叉树的根节点。

2.确定终止条件

有两个树遍历的节点t1 和 t2，有一个是Null，合并后就取另外节点的值。

3.确定单层递归的逻辑：

重复利用t1树，即合并之后树的根节点。

在单层递归中，把两棵树的元素加到一起，那么t1 的左子树就是合并 t1左子树 t2左子树之后的左子树。t1 的右子树是合并 t1右子树 t2右子树之后的右子树。

最终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;
    }
}

Leetcode700 二叉搜索树中的搜索

题目链接：Leetcode700 二叉搜索树中的搜索

第一想法：后序遍历吗？先搜索再返回树。

讲解后想法：

递归法

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

迭代法

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;
    }
}

Leetcode98 验证二叉搜索树

题目链接：Leetcode98 验证二叉搜索树

第一想法：跟700有点像，递归判断一下，不符合条件直接返回false。

讲解后想法：重点是在中序遍历下，输出的二叉搜索树节点的数值是有序序列。

用这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

递归三部曲

1.确定递归函数，返回值以及参数

要定义一个longlong的全局变量，用来比较遍历的节点是否有序，因为后台测试数据中有int最小值，所以定义为longlong的类型，初始化为longlong最小值。

注意递归函数要有bool类型的返回值， 我们在寻找一个不符合条件的节点，如果没有找到这个节点就遍历了整个树，如果找到不符合的节点了，立刻返回。

2.确定终止条件

如果是空节点，返回true。

3.确定单层递归的逻辑

中序遍历，一直更新maxVal，一旦发现maxVal >= root->val，就返回false，注意元素相同时候也要返回false。

（ps：如果测试数据中有 longlong的最小值，建议避免初始化最小值，取最左面节点的数值来比较。）

难点/细节：

陷阱1：不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。而是左子树所有节点小于中间节点，右子树所有节点大于中间节点。

陷阱2：样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。此时可以初始化比较元素为longlong的最小值。

代码：

class Solution {
    //递归
    TreeNode max;
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        // 左
        boolean left = isValidBST(root.left);
        if (!left) {
            return false;
        }
        // 中
        if (max != null && root.val <= max.val) {
            return false;
        }
        max = root;
        // 右
        boolean right = isValidBST(root.right);
        return right;
    }
}