largestBSTSubtree

#include "stdafx.h"
#include <iostream>
#include "limits.h"
using namespace std;

typedef struct treenode
{
    struct treenode *l;
    struct treenode *r;
    int value;
}TreeNode,*TreeNodePtr;
bool result = true;
int number = 0;
void IsBst(TreeNodePtr root)//If it is BST then return the number of the nodes it contains else return 0
{
    if (!root)
        return;
    static int  lastvalue = INT_MIN;
    static int curvalue;
    if (!root->l)
        IsBst(root->l);
    curvalue = root->value;
    if (lastvalue >= curvalue)
        result = false;
    lastvalue = curvalue;
    if (!root->r)
        IsBst(root->r);
}
void CountBst(TreeNodePtr root)
{
    if (!root)
        return;
    CountBst(root->l);
    number++;
    CountBst(root->r);
}

int FindTheMaxBst(TreeNodePtr root)
{
    if (!root)
        return 0;
    result = true;
    IsBst(root);
    if (result)
    {
        number = 0;
        CountBst(root);
        return number;
    }
    else
    {
        int lmax = FindTheMaxBst(root->l);
        int rmax = FindTheMaxBst(root->r);
        return lmax >= rmax ? lmax : rmax;
    }
}

上面的代码不是o(n)的复杂度

下面的代码对每棵树统计了是不是BST 如果是最大的value 最小value
size是多少 然后将这个信息进行返回是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 = {0};
        helper(root, res);
        return res[0];
    }

    private Node helper(TreeNode root, int [] res){
        Node cur = new Node();
        if(root == null){
            cur.isBST = true;
            return cur;
        }
        Node left = helper(root.left, res);
        Node right = helper(root.right, res);
        if(left.isBST && root.val > left.max && right.isBST && root.val < right.min){
            cur.isBST = true;
            cur.min = Math.min(root.val, left.min);
            cur.max = Math.max(root.val, right.max);
            cur.size = left.size + right.size + 1;
            if(cur.size > res[0]){
                res[0] = cur.size;
            }
        }
        return cur;
    }
}

class Node{
    boolean isBST;
    int min;
    int max;
    int size;
    public Node(){
        isBST = false;
        min = Integer.MAX_VALUE;
        max = Integer.MIN_VALUE;
        size = 0;
    }
}