[LeetCode] Validate Binary Search Tree

方法一：若是bst，中序便利后一定是有序，递增的。可以中序遍历后查看是否递增来判断

class Solution {
    public:
        bool isValidBST(TreeNode *root) {
            
            if(root == NULL)
                return true;
            vector<int> result;
            stack<TreeNode*> st;

            TreeNode* p = root;

            // inorder traverse
            while(p != NULL || st.size() != 0)
            {
                while(p != NULL)
                {
                    st.push(p);
                    p = p->left;
                }

                if(!st.empty())
                {
                    p = st.top();
                    st.pop();
                    result.push_back(p->val);
                    p = p->right;
                }
            }
            
            //check if it is ascend
            for(int i = 0; i < result.size()-1; i++)
            {
                if(result[i] < result[i+1])
                ;
                else
                    return false;
            }
            return true;

        }
};

方法二：使用递归，判断当前节点的值，是否在上边界和下边界之间，对于根节点，就是没有边界。然后递归判断

class Solution {
    public:
        bool isValidBST(TreeNode *root) {
            return isValidBST(root, INT_MIN, INT_MAX);
        }   
        bool isValidBST(TreeNode *root, int min, int max) 
        {   
            if(root == NULL) return true;

            if( (root->val < max) && (root->val > min) &&
                    isValidBST(root->left, min, root->val) &&
                    isValidBST(root->right, root->val, max) 
              )   
                return true;
            else
                return false;
        }   
};

方法3： 方法二没有Ac，由于两个INT_MIN出现时，所以考虑用long long 代替int即可

class Solution {
    public:
        bool isValidBST(TreeNode *root) {
            return isValidBST(root, (long long)INT_MIN - 1, (long long)INT_MAX + 1);
        }
        bool isValidBST(TreeNode *root, long long min, long long max)
        {
            if(root == NULL) return true;

            if( (root->val < max ) && (root->val > min) &&
                    isValidBST(root->left, min, root->val) &&
                    isValidBST(root->right, root->val, max) 
              )   
                return true;
            else
                return false;
        }   
};