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

目录

654.最大二叉树

617.合并二叉树

700.二叉搜索树中的搜索

1、二叉搜索树中的搜索(迭代法实现)

700.二叉搜索树中的搜索（递归法实现）

98.验证二叉搜索

---

654.最大二叉树

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

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

题解思路：

先确定左闭右闭的原则，然后重构函数，使得每次递归不去构造新数组，根据下标索引值去进行递归，比较省时间！！！看卡哥视频思路解析，注意递归的终止条件，视频里面说的注意分辨，有缺陷其实！！！

/**
 * 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 constructMaximumBinaryTree(nums, 0, nums.length - 1);
    }
    
    //左闭右闭
    public TreeNode constructMaximumBinaryTree(int[] nums, int start, int end){ //每次递归不去构造新数组，根据下标索引值来指定范围内的数组去进行递归，比较省时间
        //第二步：递归终止条件，踩过的坑！！！这里一定是判断不能构造节点的时候，才能宣告递归结束
        if(end - start < 0) return null; //数组里面没有元素了，此时递归结束
        if(end - start == 0) return new TreeNode(nums[start]); //数组里面只有一个元素，因此构造最后一个节点，这步可以省略，写上为了减少一次递归而已

        //第三步：处理单层逻辑
        int maxValue = nums[start]; //数组中的最大值
        int index = start;    //数组中最大值的位置
        for(int  i = start; i <= end; i++){  //在给定的数组范围内查找最大值!!!踩过的坑，不能是在整个数组中查找最大值
            if(nums[i] > maxValue){
                maxValue = nums[i];
                index = i;
            }
        }
        TreeNode node = new TreeNode(nums[index]);
        node.left = constructMaximumBinaryTree(nums, start, index - 1);
        node.right = constructMaximumBinaryTree(nums, index + 1, end);
        return node;

    }
}

---

617.合并二叉树

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

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

题解思路：

本题没有构造新的二叉树存放，直接在tree1上修改，然后注意这里递归遍历的时候是两个二叉树同步遍历，不是异步遍历的，所以tree1遍历到哪个位置的节点，tree2就遍历到哪个位置的节点了，最后多看卡哥视频理解里面的思路！！！

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

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

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

题解思路：

1、二叉搜索树中的搜索(迭代法实现)

因为二叉搜索树的特点，二叉搜索树是一个有序树，即左子树上所有结点的值均小于它的根结点的值，右子树上所有结点的值均大于它的根结点的值。所以本题在使用循环迭代法去遍历的时候，直接根据节点的值去判断是向左子树迭代循环还是向右子树迭代循环

/**
 * 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(val > root.val) root = root.right; //如果val值大于根节点的值，则向右子树去迭代循环
            else if(val < root.val) root = root.left; //如果val值小于根节点的值，则向左子树去迭代循环
            else return root;  //如果val值等于根节点的值，则直接返回该节点的值即可
        }
        return null; //如果没找到就返回null值
    }
}

700.二叉搜索树中的搜索（递归法实现）

题解思路：

多看卡哥视频讲解yyds！！！说的已经很详细了。因为二叉搜索树的特点，二叉搜索树是一个有序树，即左子树上所有结点的值均小于它的根结点的值，右子树上所有结点的值均大于它的根结点的值。所以本题在使用递归法实现的时候，直接根据节点的值去判断是向左子树递归还是向右子树递归

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

        //第三步：确定单层处理逻辑
        TreeNode result = null;
        if(val > root.val) result = searchBST(root.right, val);
        if(val < root.val) result = searchBST(root.left, val);
        return result;
    }
}

---

98.验证二叉搜索

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

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

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

题解思路：

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

    public boolean isValidBST(TreeNode root) {
        //第二步：终止条件
        if(root == null)  return true; //空节点什么树都是！！！

        //第三步：确定单层处理逻辑
        //这里注意对二叉搜索树使用中序遍历的方式的时候，即左右中，再结合二叉搜索树的特性，天然的形成了遍历的节点的val一直是递增的状态，所以只需要用前一个节点的值与后一个节点的值进行比较即可快速返回正确的值
        
        if(!isValidBST(root.left)) return false; //如果左子树遇到不符合二叉搜索树，则直接返回false即可
        if(pre != null && pre.val >= root.val) return false; //注意要大于等于，搜索树里不能有相同元素。用前一个节点的val值与后一个节点值进行比较，如果前一个节点的值大于等于后一个节点的值，则肯定不是二叉搜素树
        pre = root;  //记录前一个节点
        if(!isValidBST(root.right)) return false; //如果右子树遇到不符合二叉搜索树，则直接返回false即可

        return true;
    }
}