代码随想录算法训练营第20天|● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/weixin_74408291/article/details/139232613

最大二叉树

题目链接

654. 最大二叉树 - 力扣（LeetCode）

思路：

二叉树的根是数组中的最大元素。
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。

本题是构建二叉树，那么就是可利用前序遍历对二叉树进行遍历。

递归3部曲

1.返回类型：TreeNode 节点类型，参数数组nums

2.递归终条件：遇到叶子节点就直接返回

3.单一递归逻辑：对左子树进行递归，对右子树进行递归

代码：

/**
 * 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 f(int[] num, int st, int ed) {
        if (ed - st < 1) {// 空节点
            return null;
        }
        if (ed - st == 1) {// 叶子节点
            return new TreeNode(num[st]);
        }
        int maxVal = 0;// 记录最大值
        int index = 0;// 记录最大值下标
        for (int i = st; i < ed; i++) {
            if (num[i] > maxVal) {
                maxVal = num[i];
                index = i;
            }
        }
        TreeNode node = new TreeNode(num[index]);

        node.left = f(num, st, index);// 左
        node.right = f(num, index + 1, ed);// 右
        return node;
    }

    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return f(nums, 0, nums.length);
    }
}

合并二叉树

题目链接：

617. 合并二叉树 - 力扣（LeetCode）

思路：

如何将两棵树合并,之前都是对一棵树进行操作，两棵树的递归逻辑与一棵树的类似，可以一起遍历

确定递归函数的参数和返回值：

首先要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

代码如下：

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

确定终止条件：

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

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

代码如下：

if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1

确定单层递归的逻辑：

单层递归的逻辑就比较好写了，这里我们重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

那么单层递归中，就要把两棵树的元素加到一起。

t1->val += t2->val;

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

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

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

代码：

/**
 * 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 mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        int Sum_val = root1.val + root2.val;
        TreeNode root = new TreeNode(0);
        root.val = Sum_val;
        root.left = mergeTrees(root1.left, root2.left);
        root.right = mergeTrees(root1.right, root2.right);
        return root;
    }
}

二叉搜索树中的搜索

题目链接：

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

二叉搜索树：

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。
二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

非空左子树的所有键值小于其根结点的键值。
非空右子树的所有键值大于其根结点的键值。
左、右子树都是二叉搜索树。

本题可直接简单递归

代码：

/**
 * 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 searchBST(TreeNode root, int val) {
            if (root == null) {
            return null;
        }
        if (root.val == val) {
            return root;
        }
       if(val< root.val){//如果val比节点的val小，就去左子树找，反之去右子树找
           return searchBST(root.left,val);
       }
        return searchBST(root.right,val);
}
}

层序遍历

代码：

/**
 * 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 searchBST(TreeNode root, int val) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root==null){
            return null;
        }
        queue.add(root);
        while (!queue.isEmpty()){
            int size=queue.size();
            for (int i = 0; i <size ; i++) {
                TreeNode temp = queue.peek();
                queue.poll();
                if(temp.val==val){
                      return temp;
                }
                  if(temp.left!=null){
                    queue.add(temp.left);   
                }
                
                if(temp.right!=null)
                {
                    queue.add(temp.right);
                }
            }
        }
        return null;
}
}

验证二叉搜索树

题目链接：

98. 验证二叉搜索树 - 力扣（LeetCode）

代码：

利用二叉搜索树的中序遍历为有序数组进行判断

/**
 * 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 LinkedList<Integer> list = new LinkedList<>();

    public void f(TreeNode node) {
        if (node == null) {
            return;
        }
        f(node.left);
        list.add(node.val);
        f(node.right);
    }

    public boolean isValidBST(TreeNode root) {
        f(root);
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i) <= list.get(i - 1)) {
                return false;
            }
        }
        return true;
    }
}

不能单纯的递归

如下：

//       if(root==null){
//           return true;
//       }
//         if(root.left!=null&&root.left.val>root.val){
//             return false;
//         }
//
//         if(root.right!=null&&root.right.val<root.val){
//             return false;
//         }
//         boolean l=isValidBST(root.left);
//         boolean r=isValidBST(root.right);
//         return l&&r;

只是对二叉搜索树的概念模糊，二叉搜索树需要满足（强调说有，并不只是，左孩子小于节点，有孩子大于节点）

非空左子树的所有键值小于其根结点的键值。
非空右子树的所有键值大于其根结点的键值。
左、右子树都是二叉搜索树。