98.leetcode-判断是否有效的二叉排序树

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.

1. 方法一：利用二叉树中序遍历的思想，二叉排序树的中序遍历是递增的。
   中序遍历非递归方法：

bool isValidBST(TreeNode* root) 
{       
        stack<TreeNode*>s;
        TreeNode* pre=NULL;
        TreeNode* p=root;
        while(p || !s.empty())
        {
            while(p)
            {
                s.push(p);
                p=p->left;
            }
            TreeNode* cur=s.top();
            s.pop();
            if(pre != nullptr)
            if(pre->val >= cur->val)
            return false;
            pre=cur;
            p=cur->right;
        }
        return true;
   }

递归方法：

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

2.方法二：也可以用前序遍历的思想

bool isValidBST(TreeNode* root) {
    return isValidBST(root, NULL, NULL);
}
bool isValidBST(TreeNode* root, TreeNode* minNode, TreeNode* maxNode) {
    if(!root) return true;
    if(minNode && root->val <= minNode->val || maxNode && root->val >= maxNode->val)
        return false;
    return isValidBST(root->left, minNode, root) && isValidBST(root->right, root, maxNode);
}