leetcode 刷题_day20_二叉树06_构造树 & 遍历多棵树 &BST

654.最大二叉树

思路

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树
数组区间为左闭右开

解题方法

描述你的解题方法

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

  
  /**
 * 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 preOrderBuildMaxTree(nums, 0, nums.length);
    }

    private TreeNode preOrderBuildMaxTree(int[] nums, int start, int end) {
        // 退出条件
        // 无
        if (end - start < 1) {
            return null;
        }
        // 叶子节点
        if (end - start == 1) {
            return new TreeNode(nums[start]);
        }

        // 中
        // 选出给定范围内的最大值作为中间节点
        int maxIndex = start;
        int maxVal = nums[maxIndex];
        for (int i = start + 1; i < end; i++) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
                maxIndex = i;
            }
        }
        TreeNode node = new TreeNode(maxVal);

        // 左
        node.left = preOrderBuildMaxTree(nums, start, maxIndex);

        // 右
        node.right = preOrderBuildMaxTree(nums, maxIndex + 1, end);

        return node;
    }
}

617.合并二叉树

思路

构建树，用前序遍历，同时遍历两个树

解题方法

描述你的解题方法

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

  
  /**
 * 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 node = new TreeNode(root1.val + root2.val);
        // 左
        node.left = mergeTrees(root1.left, root2.left);
        // 右
        node.right = mergeTrees(root1.right, root2.right);

        return node;
    }
}

700.二叉搜索树中的搜索

思路

基于 BST 的特性，不用遍历整棵树，根据值的大小判定搜索左子树还是右子树

解题方法

描述你的解题方法

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

  
  /**
 * 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 (root.val > val) {
            return searchBST(root.left, val);
        }
        if (root.val < val) {
            return searchBST(root.right, val);
        }

        return null;
    }
}

98.验证二叉搜索树

思路

使用中序递归遍历，中序遍历出来的数组，应当是递增的，因此每次递归都更新

解题方法

1. 不能单纯的比较左节点小于中间节点，右节点大于中间节点
2. 要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点，借用 preMax 保证当前值小于所有之前的值

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

  
  /**
 * 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 {
    // 1. 不能单纯的比较左节点小于中间节点，右节点大于中间节点
    // 要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点，借用 preMax 保证当前值小于所有之前的值
    private long preVal = Long.MIN_VALUE;
    // 2. 使用中序递归遍历，中序遍历出来的数组，应当是递增的，因此每次递归都更新
    public boolean isValidBST(TreeNode root) {
        // 终止条件
        if (root == null) {
            return true;
        }

        // 左
        boolean leftValid = isValidBST(root.left);

        // 中
        // 不符合的情况
        if (preVal >= root.val) {
            return false;
        }

        preVal = root.val;

        // 右
        boolean rightValid = isValidBST(root.right);

        return leftValid && rightValid;
    }
}