代码随想录第十六天|最大二叉树 |合并二叉树 |二叉搜索树中的搜索 |验证二叉搜索树

如果全是返回值全在if语句中的话，编译器会报错，没有返回值，因为编译器会认为加入全都不满足if判断条件的话就回没有返回值。（个人理解）

最大二叉树

总结：构造二叉树类的题使用前序遍历。

构造最大二叉树和之前的中序和后序遍历构建二叉树方法类似。首先找到数组中最大的元素，即为二叉树的根节点；通过根节点所在位置的索引对数组进行左右划分，划分出根节点的左子树和右子树。通过左右区间再次进行左右递归。

终止条件：遍历到叶子节点，返回

单层处理逻辑：先找到数组中最大值作为根节点，然后再划分区间，这里划分区间一定要注意边界条件，左闭右开，一想到划分区间就要想到区间设置是什么。划分区间后再进行左右递归。

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {

        TreeNode root=getbinary(nums,0,nums.length);//左闭右开
        return root;
    }
    public TreeNode getbinary(int[] nums,int begin,int end){
        //终止条件：数组中没有元素;数组中只有一个元素
        if(end<=begin){//因为是左闭右开
            return null;
        }
        if(end-begin==1){//说明递归到了叶子节点
            return new TreeNode(nums[begin]);
        }

        //找到数组中最大值以及最大值对应索引,相当于是中的处理
        int maxIndex=begin;
        int maxValue=nums[maxIndex];
        for(int i=begin+1;i<end;i++){
            if(nums[i]>maxValue){
                maxValue=nums[i];
                maxIndex=i;
            }
        }
        TreeNode root=new TreeNode(maxValue);

        root.left=getbinary(nums,begin,maxIndex);

        root.right=getbinary(nums,maxIndex+1,end);

        return root;
        
    }
}

合并二叉树

合并二叉树也可以归为构造二叉树。使用前序遍历，为了节省内存资源，直接在tree1上进行合并。这里递归直接同时遍历处理两棵二叉树即可

终止条件：如果tree1为null，则直接合并tree2，同理，tree2为null时，直接合并tree1.这里很巧妙，将tree1和tree2同时为null的情况也进行了合并。

单层处理逻辑：中处理：将两个二叉树对于节点的值进行相加。然后左右子树做递归

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //终止条件：root1或者root2为空
        if(root1==null) return root2;
        if(root2==null) return root1;
        //中处理,直接在root1上修改，不新建二叉树
        root1.val+=root2.val;
        root1.left=mergeTrees(root1.left,root2.left);//左
        root1.right=mergeTrees(root1.right,root2.right);//右
        return root1;

    }
}

二叉搜索树中的搜索

利用二叉搜索树的特性，递归和迭代法都好实现，这里遇到了一个小问题，就是如果全是返回值全在if语句中的话，编译器会报错，没有返回值，因为编译器会认为加入全都不满足if判断条件的话就回没有返回值。（个人理解）

递归法：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        //终止条件：遍历到叶子节点
        if(root==null){
            return null;
        }
        //中处理
        if(root.val==val){
            return root;
        }else if(root.val>val){
            return searchBST(root.left,val);
        }else {
            return searchBST(root.right,val);
        }
        
    }
}

迭代法：

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

验证二叉搜索树

这里没有完全理解二叉树的前中后序遍历方式，中序遍历是完美符合搜索二叉树的特性，通过中序遍历得到的将会是一个递增的序列。这里一上手就掉入了陷阱，直接判断根节点与左右子节点的关系，没有考虑到应该是根节点与左右子树的大小关系。

终止条件：遍历到叶子节点之后

单层处理逻辑：先左子树递归找到最左边的叶子节点，定义一个“指针”执行最左边的叶子节点，每一次递归返回的时候，指针也跟着递归移动接着指向返回的节点。对指针所指节点和递归返回节点进行大小比较，也相当于数组中比较连续两个元素的大小来判读数组是否是递增的。

class Solution {
    TreeNode pre=null;
    public boolean isValidBST(TreeNode root) {
        //中序遍历完美符合二叉搜索树的特性，递增序列
        if(root==null){//终止条件
            return true;
        }
        boolean left=isValidBST(root.left);//左
        if(pre!=null&&pre.val>=root.val){//中处理，使用双指针
            return false;
        }
        pre=root;
        boolean right=isValidBST(root.right);//右
        return left&&right;     
    }

}