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.

分析：http://www.cnblogs.com/grandyang/p/5188938.html

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

int largestBSTSubtree(TreeNode root) {
        int[] res = new int[1];
        helper(root, res);
        return res[0];
    }
    void helper(TreeNode root, int[] res) {  // assume eacho node is the root
        if (root == null) return;
        int d = count(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
        res[0] = Math.max(res[0], d);
        helper(root.left, res);
        helper(root.right, res);
    }
    
    int count(TreeNode root, int mn, int mx) { // check whether it is a BST, if no, return -1, if yes, return its # of nodes.
        if (root == null) return 0;
        if (root.val < mn || root.val > mx) return -1;
        int left = count(root.left, mn, root.val);
        if (left == -1) return -1;
        int right = count(root.right, root.val, mx);
        if (right == -1) return -1;
        return left + right + 1;
    }

 O(n)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int largestBSTSubtree(TreeNode root) {
        int[] res = new int[1];
        largestBSTHelper(root, res);
        return res[0];
    }
    
    private Data largestBSTHelper(TreeNode root, int[] res) {
        Data curr = new Data();
        if (root == null) {
            curr.isBST = true;
               return curr;
        }

        Data left = largestBSTHelper(root.left, res);
        Data right = largestBSTHelper(root.right, res);
        if (left.isBST && root.val > left.max && right.isBST && root.val < right.min) {
            curr.isBST = true;
            curr.size = 1 + left.size + right.size;
            curr.min = Math.min(root.val, left.min);
            curr.max = Math.max(root.val, right.max);
            res[0] = Math.max(res[0], curr.size);
        }
           return curr;
    }
}

class Data {
    boolean isBST = false;
    // the minimum for right sub tree or the maximum for right sub tree
    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    // if the tree is BST, size is the size of the tree; otherwise zero
    int size = 0;
}

http://blog.csdn.net/likecool21/article/details/44080779