验证二叉搜索树

题目给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int prev;
    bool flag=true;
    bool check(TreeNode* root){
       if(root==nullptr)
       return true;
       bool left=check(root->left);
       if(!left) return left;
       if(flag){
           prev=root->val;
           flag=false;
       }
       else if(root->val<=prev) 
       return false;
       else prev=root->val;
       bool right=check(root->right);
       if(!right) return right;
       return true;

    }
    bool isValidBST(TreeNode* root) {
         return check(root);
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 //第二种从root开始出发分别检查左右子树
class Solution {
public:
    bool inorder(TreeNode* root,long long min,long long max){
        if(root==nullptr) return true;
        //层序遍历
        if(root->val<=min||root->val>=max)
          return false;
        return inorder(root->left,min,root->val)&&inorder(root->right,root->val,max);

    }
    bool isValidBST(TreeNode* root) {
        return inorder(root,LONG_MIN,LONG_MAX);
    }
};

第三种是我没有想到的，以这种方式进行中序遍历，多多学习
从底部开始检测每一个节点

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;
        stack<TreeNode*> nodes;
        long long inorder = (long long)INT_MIN - 1;
        //用来比较
        while(root!=nullptr||!nodes.empty()){
        //终止条件
        //根为空代表右子树为空，但是还可以有检测栈里面的父节点
        //栈为空，只要root不为空，说明右子树还可以继续遍历
        //root==nullptr&&栈为空代表没有父节点且右子树为空，遍历结束
            while(root!=nullptr){
                nodes.push(root);
                root=root->left;
            }
            root=nodes.top();
            nodes.pop();
            if(root->val<=inorder)
                return false;
            inorder=root->val;
            root=root->right;

        }
        return true;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
      if(root==nullptr) return true;
      stack<TreeNode*> stack;
      long long prev=LONG_MIN;
      while(root!=nullptr||!stack.empty()){
                 while(root!=nullptr){
                     stack.push(root);
                     root=root->left;
                 }
                 root=stack.top();
                 stack.pop();
                 if(root->val<=prev)
                 return false;
                 prev=root->val;
                 root=root->right;
      }
      return true;
    }
};