Leetcode#98. Validate Binary Search Tree

  二叉搜索树又叫二叉查找树（Binary Search Tree），定义如下：

• （1）一棵空树
• （2）若左子树不空，则左子树所有结点的值都小于根节点的值；若右子树不空，则右子树所有结点的值都大于根节点的值

  也就是说，一棵二叉搜索树的中序遍历肯定是递增序列，若不是递增序列，则一定不是二叉搜索树。

以下是C++实现源码：

20180421更新

（1）先对二叉树中序遍历，保存在 vector 中，判断 vector 是否是递增的。

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

（2）看到大神们的另一种递归解法，非常简单

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

（3）最初的解法，非递归遍历

//判断是否为二叉搜索树
bool isValidBST(TreeNode* root) {
        if(root == NULL)
            return true;
        stack<TreeNode*> s;
        TreeNode* p = root;
        TreeNode* pre = NULL;

        while(p != NULL || !s.empty())
        {
            while(p != NULL)
            {
                s.push(p);
                p = p->left;
            }
            p = s.top();
            s.pop();
            if(pre == NULL)
            {
                pre = p;
            }
            else
            {
                if(p->val <= pre->val)
                    return false;
            }
            pre = p;
            p = p->right;
        }
        return true;
    }