day17 | | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

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

Leetcode 654.最大二叉树

题目链接：https://leetcode.cn/problems/maximum-binary-tree/submissions/548996184/

思路：

1、递归

代码1：递归

/**
 * 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 counstruct(nums,0,nums.length);
    }
    public TreeNode counstruct(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 maxValue = nums[maxIndex];
        // 寻找最大值
        for(int i = leftIndex + 1 ; i < rightIndex ; i++){
            if(nums[i] > maxValue){
                maxValue = nums[i];
                maxIndex = i;
            }
        }

        // 定义根节点，值为最大值
        TreeNode root = new TreeNode(maxValue);
        // 根据maxIndex划分左右子树
        // 最大值所在下标的左区间，构造左子树
        root.left = counstruct(nums , leftIndex , maxIndex);
        // 最大值所在下标的右区间，构造右子树
        root.right = counstruct(nums, maxIndex+1 , rightIndex);
        return root;
    } 
}

Leetcode 617、合并二叉树

题目链接：https://leetcode.cn/problems/merge-two-binary-trees/description/

思路：

1、递归

• 不重新定义一个树
• 重新定义一个树

2、迭代

• 队列
• 栈

图示：演示栈

代码1：递归（不重新定义一个树）

/**
 * 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) {
       return sumTree(root1,root2);
        
    }
    // 确定函数参数和返回值
    public TreeNode sumTree(TreeNode root1,TreeNode root2){
        // 递归终止条件
        // 当root1遍历到为空
        if(root1 == null) return root2;
        // 当root2遍历到为空
        if(root2 == null) return root1;
        
        // 修改root1的结构，不重新声明树
        root1.val += root2.val;//中
        root1.left = sumTree(root1.left,root2.left);//左
        root1.right = sumTree(root1.right,root2.right);//右
        return root1;
    } 
}

代码2：递归（重新定义一个树）

/**
 * 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;
        // 定义一个新的树
        TreeNode newTree = new TreeNode(0);
        newTree.val = root1.val + root2.val;
        newTree.left = mergeTrees(root1.left , root2.left);
        newTree.right = mergeTrees(root1.right,root2.right);
        return newTree;
    }
}

代码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 mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null) return root2;
        if(root2 == null) return root1;

        // 声明队列
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root1);
        queue.offer(root2);
        while(!queue.isEmpty()){
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();

            // 两个节点不为空的情况
            node1.val += node2.val;

            // 两个树的左节点不为空
            if(node1.left != null&& node2.left != null){
                queue.offer(node1.left);
                queue.offer(node2.left);
            }

            // 两个树的右节点不为空
            if(node1.right != null&& node2.right != null){
                queue.offer(node1.right);
                queue.offer(node2.right);
            }

            // 如果node1的左节点为空
            if(node1.left == null && node2.left != null){
                node1.left = node2.left;
            }

            // 如果node1的右节点为空
            if(node1.right == null && node2.right != null){
                node1.right = node2.right;
            }
        }
        return root1;
    }
}

代码4：迭代（栈）

/**
 * 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> st = new Stack<>();
        st.push(root2);
        st.push(root1);
        while(!st.isEmpty()){
            TreeNode node1 = st.pop();
            TreeNode node2 = st.pop();
            node1.val+=node2.val;
            if(node1.right!=null && node2.right != null){
                st.push(node2.right);
                st.push(node1.right);
            }else{
                if(node1.right == null){
                    node1.right = node2.right;
                }
            }

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

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

题目链接：https://leetcode.cn/problems/search-in-a-binary-search-tree/submissions/549445200/

思路：

1、递归

2、迭代

代码1：递归

/**
 * 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;
        // 定义暂存指针,将目标值的指针接住
        TreeNode result = null;

        if(val<root.val) result = searchBST(root.left,val);
        if(val>root.val) result = searchBST(root.right,val);

        return result;
    }
}

代码2：迭代

/**
 * 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. 验证二叉搜索树

题目链接：(https://leetcode.cn/problems/validate-binary-search-tree/)

思路：

1、递归

代码1：递归

/**
 * 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 {
        // 双指针 pre 、root
        TreeNode pre;
    public boolean isValidBST(TreeNode root) {
        // 此题需要注意左子树和右子树也要满足二叉搜索树的条件

        
        if(root == null) return true;
        boolean left = isValidBST(root.left);//左
        if(!left){
            return false;
        }
        if(pre!=null && pre.val >= root.val){//中
            return false;
        }
        pre = root;
        boolean right = isValidBST(root.right);//右
        return right;
    }
}