Question:

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than the node‘s key.
• The right subtree of a node contains only nodes with keys greater than the node‘s key.
• Both the left and right subtrees must also be binary search trees.

Example 1:

    2
   /   1   3

Binary tree [2,1,3],
return true.

Example 2:

    1
   /   2   3

Binary tree [1,2,3],
return false.

判断是否为有效的二叉搜索树

Algorithm：

BST（二叉搜索树）：

1、左子树上的所有结点的值均小于它的根结点的值

2、右子树上的所有结点的值均大于它的根结点的值

3、任意结点的左右子树也分别为二叉搜索树

4、没有键值相等的结点

两种解法（耗时差不多）

1、用定义的方法，要注意不是左孩子小于根节点，是左子树的所有结点。

2、中序遍历，如果是顺序的就是有效的

Accepted Code：（解法1，定义）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {    //易错点，不是左结点的值小于根节点的值，是左子树所有的结点小于根节点
public:  //解法1
//即左<根<右，初始化时带入系统最大值和最小值，在递归过程中换成它们自己的节点值，用long代替int就是为了包括int的边界条件。
    bool isValidBST(TreeNode* root) {
        return helper(root,LONG_MIN,LONG_MAX);
    }
    bool helper(TreeNode* root,long left,long right)
    {
        if(root==NULL)
            return true;
        if(root->val<=left||root->val>=right)
            return false;
        return helper(root->left,left,root->val)&&helper(root->right,root->val,right);
    }
};

解法2（中序遍历）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {  //解法2，中序遍历,左根右
public:
    vector<int> res;
    bool isValidBST(TreeNode* root) {
        if(root==NULL)return true;
        inorder(root);
        for(int i=0;i<res.size()-1;i++)
            if(res[i]>=res[i+1])
                return false;
        return true;
    }
    void inorder(TreeNode* root)
    {
        stack<TreeNode*> s;
        while(root!=NULL||!s.empty())
        {
            if(root!=NULL)
            {
                s.push(root);
                root=root->left;
                continue;
            }
            else
            {
                root=s.top();
                s.pop();
                res.push_back(root->val);
                root=root->right;
            }
        }
    }
};