Validate Binary Search Tree

题目要求判断一颗二叉树是否是有效的二叉搜索树

#include<iostream>
#include<vector>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(NULL),right(NULL){};
};
class Solution1 
{
public:
    bool judge(TreeNode* root)
    {
        if(!root)
            return true;
        if(!left(root->left,root->val)||!right(root->right,root->val))
            return false;
        return judge(root->left)&&judge(root->right);
    }
    bool left(TreeNode* root,int value)
    {
        if(!root)
            return true;
        if(root->val>=value)
            return false;
        return left(root->left,value)&&left(root->right,value);
    }
    bool right(TreeNode* root,int value)
    {
        if(!root)
            return true;
        if(root->val<=value)
            return false;
        return right(root->left,value)&&right(root->right,value);
    }

};

class Solution2
{
public:
    int min;
    int max;
    Solution2(int min=-2147483648,int max=2147483647):min(min),max(max){};
    bool judge(TreeNode* root)
    {
        return searchTree(root,min,max);
    }
    bool searchTree(TreeNode* root,int min,int max)
    {
        if(!root)
            return true;
        if(root->val<=min||root->val>=max)
            return false;
        return searchTree(root->left,min,root->val)&&searchTree(root->right,root->val,max);
    }
};

class Solution3
{
public:
    vector<TreeNode*> res;
    void inorder(TreeNode* root)
    {   
        if(!root)
            return;
        inorder(root->left);
        res.push_back(root);
        inorder(root->right);
    }
    bool judge(TreeNode* root)
    {
        inorder(root);      
        if(res.empty())
            return true;
        for(int i=0;i<res.size()-1;i++)
            if(res[i]>res[i+1])
                return false;       
        return true;
    }
};

class Solution4
{
public:
    TreeNode* pre;
    Solution4(TreeNode* node=NULL):pre(node){};
    bool judge(TreeNode* root)
    {
        if(!root)
            return true;
        if(!judge(root->left))
            return false;
        if(pre&&root->val<=pre->val)    
            return false;
        pre=root;
        return judge(root->right);
    }
};
void main()
{
    Solution4 solution;
    TreeNode* node1=new TreeNode(1);
    TreeNode* node2=new TreeNode(2);
    TreeNode* node3=new TreeNode(3);
    TreeNode* node4=new TreeNode(4);
    TreeNode* node5=new TreeNode(5);
    TreeNode* node6=new TreeNode(6);
    node4->left=node2;
    node4->right=node6;
    node2->left=node1;
    node2->right=node3;
    node6->left=node5;
    cout<<solution.judge(node4);
}