代码随想录算法训练营第十七天|LeetCode 654，617，700，98

目录

LeetCode 654.最大二叉树

LeetCode 617.合并二叉树

LeetCode 700.二叉搜索树中的搜索

LeetCode 98.验证二叉搜索树

---

 

LeetCode 654.最大二叉树

文章讲解：代码随想录

视频讲解：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

力扣题目：LeetCode 654.最大二叉树

代码如下（Java）：

/**
 * 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];

        for(int i = leftIndex + 1; i < rightIndex; i++){
            if(nums[i] > maxVal){
                maxVal = nums[i];
                maxIndex = i;
            }
        }

        TreeNode root = new TreeNode(maxVal);

        root.left = constructMaximumBinaryTree1(nums, leftIndex, maxIndex);
        root.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);
        
        return root;
    }
}

---

LeetCode 617.合并二叉树

文章讲解：代码随想录

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

力扣题目：LeetCode 617.合并二叉树

代码如下（Java）：迭代法 

/**
 * 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;

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root2);
        stack.push(root1);

        while(!stack.isEmpty()){

            TreeNode node1 = stack.pop();
            TreeNode node2 = stack.pop();
            node1.val += node2.val;

            if(node2.right != null && node1.right != null){
                stack.push(node2.right);
                stack.push(node1.right);
            }else{
                if(node1.right == null){
                    node1.right = node2.right;
                }
            }

            if(node2.left != null && node1.left != null){
                stack.push(node2.left);
                stack.push(node1.left);
            }else{
                if(node1.left == null){
                    node1.left = node2.left;
                }
            }
        }

        return root1;
    }
}

 代码如下（Java）：递归

/**
 * 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;

        root1.val += root2.val;
        root1.left = mergeTrees(root1.left, root2.left);
        root1.right = mergeTrees(root1.right, root2.right);

        return root1;
    }
}

---

LeetCode 700.二叉搜索树中的搜索

文章讲解：代码随想录

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

力扣题目：LeetCode 700.二叉搜索树中的搜索

代码如下（Java）：递归

/**
 * 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 || root.val == val) return root;

        if(val < root.val)  return searchBST(root.left, val);
        else    return searchBST(root.right, val);
    }
}

 代码如下（Java）：迭代法

/**
 * 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) {

        while(root != null){
            if(val < root.val)  root = root.left;
            else if(val > root.val) root = root.right;
            else    return root;
        }

        return null;
    }
}

---

 LeetCode 98.验证二叉搜索树

文章讲解：代码随想录

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

力扣题目：LeetCode 98.验证二叉搜索树

代码如下（Java）：

/**
 * 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 {

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