【代码随想录训练营】Day20-二叉树

代码随想录训练营 Day20

今日任务

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

654. 最大二叉树

链接：https://leetcode.cn/problems/maximum-binary-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 {
    Map<Integer, Integer> map;
    public TreeNode buildTree(int[] nums, int left, int right){
        if(left > right){
            return null;
        }
        int maxNum = -1;
        for(int i = left; i <= right; i++){
            maxNum = maxNum > nums[i] ? maxNum : nums[i];
        }
        TreeNode root = new TreeNode(maxNum);
        root.left = buildTree(nums, left, map.get(maxNum) - 1);
        root.right = buildTree(nums, map.get(maxNum) + 1, right);
        return root;
    }
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        map = new HashMap<Integer, Integer>();
        for(int i = 0; i < nums.length; i++){
            map.put(nums[i], i);
        }
        //左闭右闭
        return buildTree(nums, 0, nums.length - 1);
    }
}

617. 合并二叉树

链接：https://leetcode.cn/problems/merge-two-binary-trees/
递归

/**
 * 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 buildTree(TreeNode root1, TreeNode root2){
        if(root1 == null && root2 == null){
            return null;
        }
        else if(root1 == null && root2 != null){
            return root2;
        }
        else if(root1 != null && root2 == null){
            return root1;
        }
        else{
            TreeNode root = new TreeNode(root1.val + root2.val);
            root.left = buildTree(root1.left, root2.left);
            root.right = buildTree(root1.right, root2.right);
            return root;
        }
    }
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null && root2 == null){
            return null;
        }
        return buildTree(root1, root2);
    }
}

层序遍历迭代

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null){
            return root2;
        }
        if(root2 == null){
            return root1;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        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);
            }
            if(node1.left == null && node2.left != null){
                node1.left = node2.left;
            }
            if(node1.right == null && node2.right != null){
                node1.right = node2.right;
            }
        }
        return root1;
    }
}

700. 二叉搜索树中的搜索

链接：https://leetcode.cn/problems/search-in-a-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 {
    TreeNode result;
    public void findNode(TreeNode root, int val){
        TreeNode node;
        if(root == null){
            result = null;
            return;
        }
        if(root.val == val){
            result = root;
        }
        if(root.val > val){
            findNode(root.left, val);
        }
        if(root.val < val){
            findNode(root.right, val);
        }
    }
    public TreeNode searchBST(TreeNode root, int val) {
        findNode(root, val);
        return result;
    }
}

迭代

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        TreeNode result = null;
        while(!queue.isEmpty()){
            TreeNode curNode = queue.poll();
            if(curNode.val == val){
                result = curNode;
                break;
            }
            else if(curNode.val < val){
                if(curNode.right != null){
                    queue.offer(curNode.right);
                }
            }
            else if(curNode.val > val){
                if(curNode.left != null){
                    queue.offer(curNode.left);
                }
            }
        }
        return result;
    }
}

迭代优化

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

98. 验证二叉搜索树

链接：https://leetcode.cn/problems/validate-binary-search-tree/
二叉搜索树按照中序遍历得到的数组一定是单调递增的
解题思路：可以把二叉搜索树看成一个数组，pre和root看成双指针，双指针不断移动，如果pre对应的值不小于root的值，就说明这个数组不是单调递增的，从而说明这个二叉树不是二叉搜索树。
递归

/**
 * 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 pre = null;
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }
        //利用二叉搜索树中序遍历数值递增的特点
        boolean leftVal = isValidBST(root.left); //左
        //根在不断左根右的过程中被包含进去了
        if(pre != null && pre.val >= root.val){
            return false;
        }
        pre = root;
        boolean rightVal = isValidBST(root.right); //右
        return leftVal == true && rightVal == true;
    }
}

迭代

class Solution {
    public boolean isValidBST(TreeNode root) {
        TreeNode pre = null;
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(cur != null || !stack.isEmpty()){
            if(cur != null){
                stack.push(cur);
                cur = cur.left; //左
            }
            else{
                cur = stack.pop(); //根
                if(pre != null && pre.val >= cur.val){
                    return false;
                }
                pre = cur;
                cur = cur.right; //右
            }
        }
        return true;
    }
}