day20 【二叉树】654.最大二叉树 | 617. 合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树

654.最大二叉树

• 654.最大二叉树 | 题目链接

• 代码随想录 | 讲解链接

• 题意：给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

  二叉树的根是数组中的最大元素。
  左子树是通过数组中最大值左边部分构造出的最大二叉树。
  右子树是通过数组中最大值右边部分构造出的最大二叉树。
  通过给定的数组构建最大二叉树，并且输出这个树的根节点。
  

• 思路：前序遍历构造二叉树——中左右

  1. 参数和返回值：传入放元素的数组，返回根节点。
  2. 确定终止条件：遇到空节点，返回空；
  3. 递归逻辑：找到最大值构造根节点，用其下标分割数组。

/**
 * 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 begin, int end) {
        if(end - begin < 1) {
            return null;
        }

        //当新划分的数组长度为1时，就没有孩子了，直接返回
        if(end - begin == 1) {
            return new TreeNode(nums[begin]);
        }

        int maxIndex = begin;
        int maxNum = nums[begin];
        for(int i = begin + 1; i < end; i++) {
            if(nums[i] > maxNum) {
                maxNum = nums[i];
                maxIndex = i;
            }
        }

        TreeNode root = new TreeNode(maxNum);
        root.left = constructMaximumBinaryTree1(nums, begin, maxIndex);
        root.right = constructMaximumBinaryTree1(nums, maxIndex + 1, end);
        return root;
    }
}

617. 合并二叉树

• 617.合并二叉树

• 代码随想录 | 讲解链接

• 题意：给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

  你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
  

• 思路：前序遍历

  1. 确定传入参数和返回值：传入两个树的根节点，返回新的根节点
  2. 终止条件：两个树，如果1为null，那么返回第二个树2（第二个为null也没事，那就返回null）；如果2为null，就返回1（括号内容同理）
  3. 递归逻辑：新节点是两个树加一起。

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

• 700.二叉搜索树中的搜索 | 题目链接
• 代码随想录 | 讲解链接
• 题意：给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
  
• 二叉搜索树：
  若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  它的左、右子树也分别为二叉搜索树
• 思路：递归，不同之处在于，二叉搜索树可的节点是有序的，可以有方向的去搜索。
  1. 确定参数和返回值：参数是二叉搜索树和要搜索的数值，返回找到的节点
  2. 终止条件：当节点为null或者找到目标节点，就返回该节点。
  3. 单层递归逻辑：如果要找的值比root.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) {
        if(root == null || root.val == val) {
            return root;
        }

        //有反方向的去搜索。
        if(root.val > val) {
            return searchBST(root.left, val);
        } else {
            return searchBST(root.right, val);
        }
    }
}

98.验证二叉搜索树

• 98.验证二叉搜索树 | 题目链接

• 代码随想录 | 讲解链接

• 题意：给定一个二叉树，判断其是否是一个有效的二叉搜索树。

  假设一个二叉搜索树具有如下特征：

  节点的左子树只包含小于当前节点的数。
  节点的右子树只包含大于当前节点的数。
  所有左子树和右子树自身必须也是二叉搜索树。
  注意：二叉搜索树中不能由重复元素。
  

• 思路：中序遍历二叉搜索树，元素的顺序是一个有序的且升序的数列。用递归中序遍历，定义一个pre结点，两两结点之间进行比较，判断此二叉树是否是二叉搜索树。

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

        //左子树
        if(!isValidBST(root.left)) {
            return false;
        }

        //如果pre不为空，且pre的值大于传入的root，按照递归顺序就不是递增了，就不是二叉搜索树，直接返回false；
        if(pre != null && pre.val >= root.val) {
            return false;
        }
        //把root传给pre，每次比较都是root和root的前一个结点进行比较
        pre = root;

        return isValidBST(root.right);
    }
}