333 Largest BST Subtree

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:

    10
    / \
   5  15
  / \   \ 
 1   8   7

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

Hint:

1. 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?

 

这道题让我们求一棵二分树的最大二分搜索子树，所谓二分搜索树就是满足左<根<右的二分树，我们需要返回这个二分搜索子树的节点个数。题目中给的提示说我们可以用之前那道Validate Binary Search Tree的方法来做，时间复杂度为O(n²)，这种方法是把每个节点都当做根节点，来验证其是否是二叉搜索数，并记录节点的个数，若是二叉搜索树，就更新最终结果

public class LagestBSTSubtree {
    public int largestBSTSubtree(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (isValid(root, Integer.MIN_VALUE, Integer.MAX_VALUE)) {
            return count(root);
        }
        return Math.max(largestBSTSubtree(root.left), largestBSTSubtree(root.right));
    }
    
    private boolean isValid(TreeNode root, int mn, int mx) {
        if (root == null) {
            return true;
        }
        if (root.val <= mn || root.val >= mx) {
            return false;
        }
        return isValid(root.left, mn, root.val) && isValid(root.right, root.val, mx);
    }
    
    private int count(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return count(node.left) + count(node.right) + 1;
    }
}

题目中的Follow up让我们用O(n)的时间复杂度来解决问题，我们还是采用DFS的思想来解题，由于时间复杂度的限制，只允许我们遍历一次整个二叉树，由于满足题目要求的 二叉搜索子树必定是有叶节点的，所以我们的思路就是先递归到最左子节点，然后逐层往上递归，对于每一个节点，我们都记录当前最大的BST的节点数，当做为左子树的最大值，和做为右子树的最小值，当每次遇到左子节点不存在或者当前节点值大于左子树的最大值，且右子树不存在或者当前节点值小于右子树的最小数时，说明BST的节点数又增加了一个，我们更新结果及其参数，如果当前节点不是BST的节点，那么我们更新BST的节点数res为左右子节点的各自的BST的节点数的较大值

class LagestBSTSubtree1 {
    public int largestBSTSubtree(TreeNode root) {
        int res = 0, mn = Integer.MIN_VALUE, mx = Integer.MAX_VALUE;
        isValidBST(root, mn, mx, res);
        return res;
    }
    
    private boolean isValidBST(TreeNode root, int mn, int mx, int res) {
        if (root == null) {
            return true;
        }
        int leftn = 0, rightn = 0, leftmn = Integer.MIN_VALUE,
                leftmx = Integer.MAX_VALUE, rightmn = Integer.MIN_VALUE,
                rightmx = Integer.MAX_VALUE;
        boolean left = isValidBST(root.left, leftmn, leftmx, leftn);
        boolean right = isValidBST(root.right, rightmn, rightmx, rightn);
        if (left && right) {
            if ((root.left == null || root.val > leftmx) && 
                    (root.right == null || root.val < rightmn)) {
                res = leftn + rightn + 1;
                mn = root.left == null ? root.val : leftmn;
                mx = root.right == null ? root.val : rightmx;
                return true;
            }
        }
        res = Math.max(leftn, rightn);
        return false;
    }
}