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

参考：代码随想录 (programmercarl.com)

1最大二叉树

初见：递归，但是不知道代码怎么写

思路：选到最大的值，分成左右区间，在进入左右区间递归

构造树一般采用的是前序遍历(中左右)，因为先构造中间节点，然后递归构造左子树和右子树；也就是就像我们画图一样，先中间，在左右；

判断参数和返回值：参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是指向节点的指针。

终止条件:区间长度为1，说明到叶子了；

单层递归的逻辑：这个有点像排序了，主要有maxIndex和maxValue;

难点在于对边界的判断，我们选择左闭右开，也就是每个区间我们处理他的【 );这意味着初始传入的是   constructMaximumBinaryTree1(nums, 0, nums.length); 0是我们要处理，nums.length不用；下面划分左右子树也是一样的；

int maxValue = 0;
int maxValueIndex = 0;
for (int i = 0; i < nums.size(); i++) {
    if (nums[i] > maxValue) {
        maxValue = nums[i];
        maxValueIndex = i;
    }
}
TreeNode* node = new TreeNode(0);
node->val = maxValue;

代码

/**
 * 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 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];// 最大值
        //这里i为什么等于leftIndex + 1,不加他也是对的，因为在上面2行leftIndex 已经是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.合并二叉树

思路：这个用递归还是很简单的，用前中后遍历都可以，分为tree A和tree B，如果ab节点相同

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

3.二叉搜索树中的搜索

思路：简单，自己都能做出来，就判断就行

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

4.验证二叉搜索树

思路：有个大坑：二叉搜索树是要他的每一个节点的左都小于他，右都大于他，所以这个不是二叉树

所以不能只判断节点的左孩子小于他，右孩子大于他

正确思路：设一个变值max,采用中值遍历(用哪种遍历很重要)，从最左的节点往中节点走（之所以采用中值变历就是在中进行判断左，在右判断中）

class Solution {
    // 递归
    TreeNode max;
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        // 左
        boolean left = isValidBST(root.left);
        if (!left) {
            return false;
        }
        // 中
        if (max != null && root.val <= max.val) {
            return false;
        }
        max = root;
        // 右
        boolean right = isValidBST(root.right);
        return right;
    }
}