98. Validate Binary Search Tree

题意：判断一个二叉树是否为二分查找树。

何为二分查找树？1) 左子树的值都比根节点小；2) 右子树的值都比根节点大；3) 左右子树也必须满足上面两个条件。

需要注意的是，左子树的所有节点都要比根节点小，而非只是其左孩子比其小，右子树同样。这是很容易出错的一点是，很多人往往只考虑了每个根节点比其左孩子大比其右孩子小。如下面非二分查找树，如果只比较节点和其左右孩子的关系大小，它是满足的。

5
/ \
4 10
/ \
3 11

错误代码示范：

class Solution {
public:
    bool 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);
    }
};

第一种方法：暴力求解法
从根节点开始递归，遍历所有的节点。并且在每个节点处，分别遍历其左右子树，判断其左子树的最大值比其小，右子树的最小值比其大。

时间复杂度为O(n^2)。

class Solution {
public:
    bool isValidBST(TreeNode* root) 
    {
        if(root==NULL)
            return true;
        if(!dfsleft(root->left,root->val)||!dfsright(root->right,root->val))
            return false;
        return isValidBST(root->left)&&isValidBST(root->right);
    }
    bool dfsleft(TreeNode *root,int value)
    {
        if(root==NULL)
            return true;
        if(root->val>=value)
            return false;
        return dfsleft(root->left,value)&&dfsleft(root->right,value);
    }
    bool dfsright(TreeNode *root,int value)
    {
        if(root==NULL)
            return true;
        if(root->val<=value)
            return false;
        return dfsright(root->left,value)&&dfsright(root->right,value);
    }
};

第二种方法：
网上很用人用了INT_MIN和INT_MAX来辅助解决这道题，即遍历时记录一个当前允许的最大值和最小值。
思路是根据一棵树的根为a，右子树为b，那么右子树的左儿子c的值一定是大于a且小于b
但如果树的值就是最大值的时候似乎bug，临界值不行。

class Solution {
    public:
    bool isValidBST(TreeNode * root) 
    {
        return isBSTRec(root, INT_MIN, INT_MAX);
    }

    bool isBSTRec(TreeNode *root, int left, int right) 
    {
        if(root == NULL) {
            return true;
        }
        if(root->val <= left || root->val >= right) {
            return false;
        }

        return isBSTRec(root->left, left, root->val) && isBSTRec(root->right, root->val, right);
    }
};

后来在leetcode上看到有人用LONG_MIN和LONG_MAX，可以运行通过

class Solution {
public:
    bool isValidBSTRec(TreeNode* root, long min, long max) {
        if(!root) return true;
        if((root->val<max) && (root->val>min)) {
            return (isValidBSTRec(root->left, min, root->val)) &&
                    (isValidBSTRec(root->right, root->val, max));  
        }
        return false; 
    }
    bool isValidBST(TreeNode* root) {
        //if(root && !root->left && !root->right) return true;
        return isValidBSTRec(root, LONG_MIN, LONG_MAX);

    }
};

第三中方法：先中序遍历搜索二叉树，再判断是不是递增序列

class Solution {
    public:
        vector<int>ret;
        bool isValidBST(TreeNode * root) 
        {
            inorder(root);
            if(ret.size()<=1)
                return true;
            for(int i=ret.size()-1;i>=1;i--)
            {
                if(ret[i]<=ret[i-1])
                    return false;
            }
            return true;
        }
        void inorder(TreeNode *root)
        {
            if(!root)
                return;
            inorder(root->left);
            ret.push_back(root->val);
            inorder(root->right);
        }
};