D17|最大、合并二叉树、二叉搜索树中的搜索、验证二叉搜索树

654.最大二叉树

初始思路：

        首先考虑前序，在数组中找到最大值作为根节点，再从其左边的数组选出最大值作为左子节点，右边选出最大值作为右子节点。

递归三部曲：1）确定递归函数的参数和返回值

                        输入一个数组，返回这个数组中值最大的元素作为我的Treenode

                        同时需要截取数组

                        2）确定终止条件

                        当数组为空或长度为零时进行return

                        3）确定单层递归的逻辑

                         在数组中找到最大值

                          在数组中找左子节点，递归一次

                        在数组中找右子节点，递归一次              

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        if(nums.length==0){return null;}
        return construct(nums,0,nums.length);
    }
    public TreeNode construct(int[] nums,int begin,int end){
        if(begin==end){return null;}
        int Maxnum = Integer.MIN_VALUE;
        int Maxindex = begin;
        for(int i=begin;i<end;i++){
            if(nums[i]>=Maxnum){
                Maxnum = nums[i];
                Maxindex = i;
            }
        }

        TreeNode node = new TreeNode(Maxnum);
        node.left = construct(nums,begin,Maxindex);
        node.right = construct(nums,Maxindex+1,end);
        return node;
    }
}

一定要注意maxindex 还有for循环中的begin和end定义准确

跟从前序和中序构造二叉树以及从后序和中序中构造二叉树基本上是一个思路的。

---

617.合并二叉树

初始思路：

递归三部曲：1）确定递归函数的参数和返回值

                          输入两个Treenode返回这两个节点的值相加作为合并后节点的新值的新节点

                        2）确定终止条件

                                （1）如果两个节点均为null也就是走到了树的终点，此时return null

                                （2）因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 ==                                         NULL 了，两个树合并就应该是 t2 了，反过来如果t2 == NULL，那么 两个数合并就是t1

                        

                        3）确定单层递归的逻辑

                              从根节点开始合并，如果是前序的话

要把两棵树的元素加到一起。

t1->val += t2->val;

接下来t1 的左子树是：合并 t1左子树 t2左子树之后的左子树。

t1 的右子树：是 合并 t1右子树 t2右子树之后的右子树。

最终t1就是合并之后的根节点。

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

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->val += t2->val;                             // 中
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

题解中：1）因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 == NULL 了，两个树合并就应该是 t2 了（如果t2也为NULL也无所谓，合并之后就是NULL）。

反过来如果t2 == NULL，那么两个数合并就是t1（如果t1也为NULL也无所谓，合并之后就是NULL）。

2）重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

---

700.二叉搜索树中的搜索

初始思路：

利用二叉搜索树的特性，如果目标值小于当前值，就从左侧子树去寻找，如果目标值大于当前值，就从右侧子树去寻找。

递归三部曲：1）确定递归函数的参数和返回值

                          输入节点和目标值，返回节点

                        2）确定终止条件

                                （1）如果找到了就返回当前节点

                                （2）如果当前节点为空，也就是找到了树的尽头都没有找到就返回当前节点

                        

                        3）确定单层递归的逻辑

                             先找当前也就是判断当前节点的值是否等于target

                             利用二叉搜索树的特性，如果目标值小于当前值，就从左侧子树去寻找，如果目标值大于当前值，就从右侧子树去寻找。

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

题解复盘：

迭代法利用了二叉搜索树特性之后变得十分简易

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        while root:
            if val < root.val: root = root.left
            elif val > root.val: root = root.right
            else: return root
        return None

---

98.验证二叉搜索树

初始思路：

        就只是递归，判断当前节点的左子节点是否小于当前节点，右子节点是否大于当前节点。

其实是不对的。

这种错误情况也会符合。

右边子树上的值也都需要大于当前节点

后续利用二叉树特性，将其存放于数组中，注意这里一定要使用！！！！中序遍历

这样可以保证数组中的是有序的，左边的值一定小于右边的值。

class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> result = inorderTraversal(root);
        for (int i = 1; i < result.size(); i++) {
            if(result.get(i-1)>=result.get(i)){
                return false;
            }
            // if(result.get(i)>=result.get(i+1)){
            //     return false;
            // }

        }
        return true;
        }
    
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
    Stack<TreeNode> st = new Stack<>();
    if (root != null) st.push(root);
    while (!st.empty()) {
        TreeNode node = st.peek();
        if (node != null) {
            st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
            if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
            st.push(node);                          // 添加中节点
            st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

            if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
        } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
            st.pop();           // 将空节点弹出
            node = st.peek();    // 重新取出栈中元素
            st.pop();
            result.add(node.val); // 加入到结果集
        }
    }
    return result;

}
}

这里练习了一下统一迭代，发现已经狠狠忘记了

题解复盘：

递归三部曲：

• 确定递归函数，返回值以及参数

要定义一个longlong的全局变量，用来比较遍历的节点是否有序，因为后台测试数据中有int最小值，所以定义为longlong的类型，初始化为longlong最小值。

代码如下：

• 确定终止条件

如果是空节点 是不是二叉搜索树呢？

是的，二叉搜索树也可以为空！

代码如下：

if (root == NULL) return true;

• 确定单层递归的逻辑

中序遍历，一直更新maxVal，一旦发现maxVal >= root->val，就返回false，注意元素相同时候也要返回false。

        

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