代码随想录算法训练营Day20|LC654 最大二叉树&LC617 合并二叉树&LC700 二叉搜索树中的搜索&LC98 验证二叉搜索树

一句话总结：简单题的递归不太难。

原题链接：654 最大二叉树

思路就是递归地构造根节点的左右子树。先划分好子树的左右边界，然后通过一趟遍历找到最大值点，最后递归构造即可。 

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return construct(nums, 0, nums.length - 1);
    }

    TreeNode construct(int[] nums, int start, int end) {
        if (start > end) return null;
        int max = start;
        for (int i = start + 1; i <= end; ++i) {
            if (nums[i] > nums[max]) {
                max = i;
            }
        }
        TreeNode root = new TreeNode(nums[max]);
        root.left = construct(nums, start, max - 1);
        root.right = construct(nums, max + 1, end);
        return root;
    }
}

 原题链接：617 合并二叉树

此题的递归显而易见，先写出空节点时的判空操作作为递归出口。然后将合并同时存在值的值之和到新的根节点所形成的树中即可。

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null || root2 == null) return root1 == null ? root2 : root1;
        TreeNode root = new TreeNode(root1.val + root2.val);
        root.left = mergeTrees(root1.left, root2.left);
        root.right = mergeTrees(root1.right, root2.right);
        return root;
    }
}

 原题链接：700 二叉搜索树中的搜索

此题也是不难。先写出递归出口，显而易见的，在根节点值等于所求val时，返回根节点；跟点点为null时，返回null。然后进行判断操作，最后递归地对左右子树进行递归操作即可。

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while (root != null) {
            if (val == root.val) return root;
            root = root.val > val ? root.left : root.right;
        }
        return null;
    }
}

原题链接：98 验证二叉搜索树 

此题最简单易懂的解法为先中序遍历整个二叉树然后将其置入一个数组中，然后判断数组是否严格递增即可。很明显的其时空复杂度较高。

class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> arr = new LinkedList<>();
        inorder(root, arr);
        boolean flag = true;
        for (int i = 0; i < arr.size() - 1; ++i) {
            if (arr.get(i) >= arr.get(i + 1)) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    void inorder(TreeNode root, List<Integer> arr) {
        if (root == null) return;
        inorder(root.left, arr);
        arr.add(root.val);
        inorder(root.right, arr);
    }
}

 然后就是递归解法。需要指出这个递归解法需要一些细节，主要是需要指出每次判断的时候需要给出这个值应有的上下界。

class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    boolean isValidBST(TreeNode root, long low, long high) {
        if (root == null) return true;
        long x = root.val;
        return low < x && x < high && isValidBST(root.left, low, x) && isValidBST(root.right, x, high);
    }
}