代码随想录DAY17|654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

终止条件与递归前是否判断
如果终止条件中有对空的判断，则递归函数调用前不用判断传入参数是否为空，因为这是可以接受的。

1. 最大二叉树

力扣
方式一：每次切出左右数组，传入递归。
在开始判断了长度是否为0，所以传入空数组也可以。
但这样会新创建很多数组，自然想到改进思路，每次传入相应数组的起始和结束位置（方式二）。

class Solution {  //方式一
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        if(nums.length == 0){
            return null;
        }
        int maxInt = -1;
        int index = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > maxInt){
                maxInt = nums[i];
                index = i;
            }
        }
        TreeNode node = new TreeNode(maxInt);
        if(nums.length == 1){
            return node;
        }
        int leftLen = index;
        int rightLen = nums.length - leftLen - 1;
        int[] leftNums = new int[leftLen];
        int[] rightNums = new int[rightLen];
        System.arraycopy(nums,0,leftNums,0,leftLen);
        System.arraycopy(nums,leftLen + 1, rightNums, 0, rightLen);
        node.left = constructMaximumBinaryTree(leftNums);
        node.right = constructMaximumBinaryTree(rightNums);
        return node;
    }
}

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

2. 合并二叉树

力扣

注意终止条件，只用判断root1 == null然后返回root2，这样即使root2 == null也无所谓，已经包括进去了，写起来比较简洁方便。遍历到每个节点有四种情况，三种是可以直接返回结果的，因此是终止条件。还有一种就是在本层进行操作的。不要混为一谈。

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null){ //此时已经包含了1、2节点为空返回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;
    }
}

3. 二叉搜索树中的搜索

终止条件是root为空或者找到了。
注意本题使用迭代法可不用栈或者队列，因为二叉搜索树已经指明了下一步的方向。

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if(root == null || root.val == val){
            return root;
        }
        if(val > root.val){
            return searchBST(root.right, val);
        }
        if(val < root.val){
            return searchBST(root.left, val);
        }
        return root;
    }
}

//迭代
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;
    }
}

4. 验证二叉搜索树

力扣
有两种思路：1.二叉搜索树中序遍历的结果必定递增。2.遍历树判断是否符合二叉搜索树的规定。
用第二种思路实现时要注意一个陷阱：判断是否符合要求，不能只比较节点和左右子节点的大小，因为还有下述情况

因此思路是用一个值prev来记录前一个节点的值，然后中序遍历，比较当前节点的值是不是更大，如果小了直接返回false，如果大就更新prev继续遍历。注意prev要定义成Long类型，因为题干中节点值可能是int的最小值，而prev要初始化成最小的。
迭代法二刷再看代码。

class Solution {
    private long prev = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }
        //中序遍历
        boolean left = isValidBST(root.left);
        if(root.val > prev){
            prev = root.val;
        }else{
            return false;
        }
        boolean right = isValidBST(root.right);
        return left && right;
    }
}