刷题日记17 | 654. 最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

刷题日记17

今天还是二叉树，尝试使用多种方法解题，理解不同的思路

654. 最大二叉树

递归法求解，前序遍历，构造二叉树一般都是前序遍历，因为要先确定二叉树的根节点，再确定左右节点，时间复杂度O(n^2)

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        if(nums.length == 0) return null;
        return build(nums, 0, nums.length - 1);
    }
    public TreeNode build(int[] nums, int left, int right){
        if(left > right) return null;
        int index = left;
        for(int i = left + 1; i <= right; i++){
            if(nums[i] > nums[index]) index = i;
        }
        TreeNode root = new TreeNode(nums[index]);

        root.left = build(nums, left, index - 1);
        root.right = build(nums, index + 1, right);
        return root;
    }
}

617. 合并二叉树

没什么说的，简单的递归，前序遍历

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

700. 二叉搜索树中的搜索

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

98. 验证二叉搜索树

中序遍历递归法

class Solution {
    public TreeNode pre = null;
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;
        boolean left = isValidBST(root.left);
        if(pre != null && pre.val > root.val) return false;
        pre = root;
        boolean right = isValidBST(root.right);
        return left && right;
    }
}

中序遍历迭代法，使用null标记中节点。

class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;
        TreeNode pre = null;
        Stack<TreeNode> s = new Stack<>();
        s.push(root);
        while(!s.isEmpty()){
            TreeNode node = s.peek();
            if(node != null){
                s.pop(); //弹出，避免重复操作
                if(node.right != null) s.push(node.right); // right
                s.push(node); //中
                s.push(null); //null标记中节点
                if(node.left != null) s.push(node.left); // left
            }else{
                s.pop(); //弹出空节点
                node = s.pop();
                if(pre != null && pre.val >= node.val) return false;
                pre = node;
            }
        }
        return true;
    }
}