代码随想录训练营第十七天 | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树（中序有序）

最新推荐文章于 2025-09-18 21:23:54 发布

原创最新推荐文章于 2025-09-18 21:23:54 发布 · 327 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #数据结构

654.最大二叉树

只是觉得不能记录好大小顺序，需要一次次遍历，有些浪费时间。

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return construct(nums, 0, nums.length); // 左闭右开
    }

    private TreeNode construct(int[] nums, int startIndex, int endIndex){
        if(startIndex >= endIndex) return null;
        int maxValue = nums[startIndex], maxValueIndex = startIndex;
        for(int i=startIndex+1; i<endIndex; i++){
            if(maxValue < nums[i]){
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        TreeNode node = new TreeNode(maxValue);
        node.left = construct(nums, startIndex, maxValueIndex);
        node.right = construct(nums, maxValueIndex+1, endIndex);
        return node;
    }
}

617.合并二叉树（同时操作两棵树；不要新建节点）

new新节点，很耗时。

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        return construct(root1, root2);
    }

    private TreeNode construct(TreeNode node1, TreeNode node2){
        if(node1==null && node2==null) return null;
        TreeNode node = new TreeNode((node1==null?0:node1.val) + (node2==null?0:node2.val));
        node.left = construct(node1==null?null:node1.left, node2==null?null:node2.left);
        node.right = construct(node1==null?null:node1.right, node2==null?null:node2.right);
        return node;
    }
}

代码随想录：

不会创建对象，只是在root1的基础上更改值，或者把root2的节点拿来。
也正因此，可以进行判断：一棵树的节点是null，就返回另一棵树的节点（即使也是null）。结束递归，不需要继续遍历。

// 递归
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;
    }
}

// 栈
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; // 更改node1的值
            if (node2.right != null && node1.right != null) { // 如果都不空，就压栈（因为右孩子可能还有子节点），随后可以遍历
                stack.push(node2.right);
                stack.push(node1.right);
            } else { // 如果有空的，只用设置为其中不为空的那个节点即可（或设为null）。不需要遍历了
                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;
    }
}

// 队列
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();
            // 此时两个节点一定不为空，val相加
            node1.val = 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;
    }
}

700.二叉搜索树中的搜索（迭代不需要栈、队列）

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

代码随想录：

普通二叉树：递归、迭代
二叉搜索树：递归、迭代
二叉搜索树的迭代不需要栈、队列，会自动回溯：

对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。
而对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。
例如要搜索元素为3的节点，我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。
中间节点如果大于3就向左走，如果小于3就向右走，如图：

class Solution {
    // 递归，普通二叉树
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        TreeNode left = searchBST(root.left, val);
        if (left != null) {
            return left;
        }
        return searchBST(root.right, val);
    }
}

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

class Solution {
    // 迭代，普通二叉树
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode pop = stack.pop();
            if (pop.val == val) {
                return pop;
            }
            if (pop.right != null) {
                stack.push(pop.right);
            }
            if (pop.left != null) {
                stack.push(pop.left);
            }
        }
        return null;
    }
}

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

98.验证二叉搜索树（中序有序）

错误解法：想简单了，以为只需要比较父子即可，

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

int存在整数溢出问题，只能使用long

class Solution {
    public boolean isValidBST(TreeNode root) {
        return valid(root, Long.MAX_VALUE, Long.MIN_VALUE);
    }

    private boolean valid(TreeNode node, long max, long min){
        if(node==null) return true;
        
        if(node.val<max && node.val>min){
            return valid(node.left, (long)node.val, min) && valid(node.right, max, (long)node.val);
        }
        return false;
    }
}

代码随想录：中序遍历是有序的，就有效。

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

class Solution {
    // 迭代
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;// 左
            }
            // 中，处理
            TreeNode pop = stack.pop();
            if (pre != null && pop.val <= pre.val) {
                return false;
            }
            pre = pop;

            root = pop.right;// 右
        }
        return true;
    }
}

// 简洁实现·递归解法
class Solution {
    public boolean isValidBST(TreeNode root) {
        return validBST(Long.MIN_VALUE, Long.MAX_VALUE, root);
    }
    boolean validBST(long lower, long upper, TreeNode root) {
        if (root == null) return true;
        if (root.val <= lower || root.val >= upper) return false;
        return validBST(lower, root.val, root.left) && validBST(root.val, upper, root.right);
    }
}
// 简洁实现·中序遍历
class Solution {
    private long prev = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        if (!isValidBST(root.left)) {
            return false;
        }
        if (root.val <= prev) { // 不满足二叉搜索树条件
            return false;
        }
        prev = root.val;
        return isValidBST(root.right);
    }
}