333. Largest BST Subtree

最新推荐文章于 2025-04-23 12:20:04 发布

原创最新推荐文章于 2025-04-23 12:20:04 发布 · 309 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

69 篇文章

订阅专栏

本文探讨了在一个给定的二叉树中找到最大的二叉搜索树子树的问题，并提出了一种利用递归策略来检查每个节点的有效性的解决方案，最终达到O(n)的时间复杂度。

Given a binary tree, find the largest subtree which is a Binary Search Tree (BST), where largest means subtree with largest number of nodes in it.

Note:
A subtree must include all of its descendants.
Here's an example:

The Largest BST Subtree in this case is the highlighted one.
The return value is the subtree's size, which is 3.

Hint:

You can recursively use algorithm similar to 98. Validate Binary Search Tree at each node of the tree, which will result in O(nlogn) time complexity.

Follow up:

Can you figure out ways to solve it with O(n) time complexity?

Solution:

At first I was thinking using in order traversal, marked out the possible start and end so we just need to find the longest increasing sequence between the a possible start and a possible end. But the thing is how to know which node is a possible start and which node is a possible end.

But it is too hard to figure out the right start and right end.

For example the in order traversal is 42135, but 135 is not the right start and end, so we also need to record the level and it is too complex, however I believe this problem can be solved with in order traversal.

Another thinking way is Divide and conquer, for the left and right subtree, get the max number of the subtree and whether it is the root of that subtree. If one of them are not the root, the whole subtree will not be a BST so just return the max of left and right subtree, otherwise check the min, max and root.val to see whether this subtree is a BST.

Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    class Result{
        int min;
        int max;
        int num;
        boolean isRoot;
        Result(int min, int max, int num, boolean isRoot){
            this.min = min;
            this.max = max;
            this.num = num;
            this.isRoot = isRoot;
        }
    }
    
    public int largestBSTSubtree(TreeNode root) {
        return helper(root).num;
    }
    
    Result helper(TreeNode root){
        if(root == null) return new Result(Integer.MAX_VALUE,Integer.MIN_VALUE,0,true);
        Result l = helper(root.left);
        Result r = helper(root.right);
        if(l.isRoot && r.isRoot){
            if(root.val > l.max && root.val < r.min){
                return new Result(Math.min(root.val,l.min), Math.max(root.val,r.max), 1 + r.num + l.num, true);  
            } 
        } 
        return new Result(0,0,Math.max(l.num,r.num),false);
    }
}