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

654.最大二叉树 

又是构造二叉树，昨天大家刚刚做完 中序后序确定二叉树，今天做这个 应该会容易一些， 先看视频，好好体会一下 为什么构造二叉树都是 前序遍历 

题目链接/文章讲解：代码随想录

视频讲解： 又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

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

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

一般情况来说：如果让空节点（空指针）进入递归，就不加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 construct(nums, 0, nums.length);
    }

    // 在左闭右开区间[left, right)，构造二叉树
    public TreeNode construct(int[] nums, int leftIndex, int rightIndex) {
        if(rightIndex - leftIndex < 1){// 没有元素了
            return null;
        }

        if (rightIndex - leftIndex == 1) {// 只有一个元素,叶子节点
            return new TreeNode(nums[leftIndex]);
        }

        // 中
        // 分割点下标：maxValueIndex, 找到数组中最大的值和对应的下标
        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);

        //左,最大值所在的下标左区间 构造左子树,
        //需不需要写if，看中止条件要求，中止条件处理了0和1的情况，所以不用限制；允许空节点进入递归，所以不用在递归的时候加判断节点是否为空
        root.left = construct(nums, leftIndex, maxIndex);

        //右,最大值所在的下标右区间 构造右子树
        root.right = construct(nums, maxIndex + 1, rightIndex);
        return root;
    }
}

---

 617.合并二叉树 

这次是一起操作两个二叉树了， 估计大家也没一起操作过两个二叉树，也不知道该如何一起操作，可以看视频先理解一下。 优先掌握递归。

题目链接/文章讲解：代码随想录

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

如何同时遍历两个二叉树呢？

其实和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作。

本题使用哪种遍历都是可以的！前序更直观便于理解

/**
 * 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 mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null) return root2;// 如果t1为空，合并之后就应该是t2
        if(root2 == null) return root1;// 如果t2为空，合并之后就应该是t1

        // 修改了t1的数值和结构
        root1.val += root2.val;// 中
        root1.left = mergeTrees(root1.left, root2.left);// 左
        root1.right = mergeTrees(root1.right, root2.right);// 右

        return root1;
    }
}

迭代法

把两个树的节点同时加入队列进行比较。

---

700.二叉搜索树中的搜索 

递归和迭代 都可以掌握以下，因为本题比较简单， 了解一下 二叉搜索树的特性

题目链接/文章讲解: 代码随想录

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

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

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

因为二叉搜索树的有序性，遍历的时候要比普通二叉树简单很多。

递归法

二叉搜索树的顺序性已经帮我们确定了遍历的顺序，所以无需前中后序遍历

对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。

而对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

/**
 * 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 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);
        }
    }
}

迭代法

一般的二叉树遍历的迭代法，需要使用栈来模拟深度遍历，使用队列来模拟广度遍历。

对于二叉搜索树可就不一样了，因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。

/**
 * 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 searchBST(TreeNode root, int val) {
        while(root != null){
            if(root.val > val) root = root.left;
            else if(root.val < val) root = root.right;
            else return root;
        }

        return null;
    }
}

---

98.验证二叉搜索树 

遇到 搜索树，一定想着中序遍历，这样才能利用上特性。 

但本题是有陷阱的，可以自己先做一做，然后在看题解，看看自己是不是掉陷阱里了。这样理解的更深刻。

题目链接/文章讲解：代码随想录

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

中序遍历下，输出的二叉搜索树节点的数值是有序序列。

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

直观法：递归中序遍历将二叉搜索树转变成一个数组，然后只要比较一下，这个数组是否是有序的，注意二叉搜索树中不能有重复元素。

/**
 * 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 boolean isValidBST(TreeNode root) {
        List<Integer> array = new ArrayList<>();
        getBST(root, array);
        for(int i = 1; i< array.size(); i++){
            // 注意要小于等于，搜索树里不能有相同元素
            if(array.get(i) <= array.get(i-1)) return false;
        }
        return true;

    }

    public void getBST(TreeNode node, List<Integer> array) {
        if(node == null) return;
        if(node.left != null) getBST(node.left, array);
        array.add(node.val);// 将二叉搜索树转换为有序数组
        if(node.right != null) getBST(node.right, array);

    }
}

 把二叉树转变为数组来判断，是最直观的，但其实不用转变成数组，可以在递归遍历的过程中直接判断是否有序。

这道题目比较容易陷入两个陷阱：

• 陷阱1：不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。
• 陷阱2：样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。此时可以初始化比较元素为longlong的最小值。

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

/**
 * 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 {
   // 递归
    long maxVal = Long.MIN_VALUE; // 因为后台测试数据中有int最小值
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;

        //左
        boolean left = isValidBST(root.left);

        //中
        if(root.val > maxVal){
            maxVal = root.val;// maxVal记录了当前节点前一个节点的数值,如果是BST就一定是root.val > maxVal
        }else{//不是BST
            return false;
        }

        //右
        boolean right = isValidBST(root.right);

        return left && right;
    }
}

如果测试数据中有 longlong的最小值，怎么办？

不可能在初始化一个更小的值了吧。 建议避免 初始化最小值，使用双指针优化递归法，取到最左面节点的数值来比较。

 

/**
 * 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 {
   // 双指针优化递归法
    TreeNode pre = null; // 因为后台测试数据中有int最小值,记录当前遍历的前一个节点
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;

        //左
        boolean left = isValidBST(root.left);

        //中
        if(pre != null && root.val <= pre.val){
            return false;// pre.val记录了当前节点前一个节点的数值,如果root.val <= pre.val,前一个节点大于后一个，一定不是BST
        }
        pre = root;// 记录前一个节点

        //右
        boolean right = isValidBST(root.right);

        return left && right;
    }
}